utils: mdldec: add separate directories creation for sequences and textures.

This needed for native support GoldSrc Monitor utility.

.cirrus.yml

@@ -0,0 +1,47 @@
+task:
+  name: freebsd-12-amd64
+  freebsd_instance:
+    image_family: freebsd-12-4
+  setup_script:
+    - pkg update
+    - pkg install -y pkgconf git sdl2 python fontconfig opus
+    - git submodule update --init --recursive
+  test_script:
+    - ./scripts/cirrus/build_freebsd.sh dedicated
+    - ./scripts/cirrus/build_freebsd.sh full
+
+task:
+  name: freebsd-13-amd64
+  freebsd_instance:
+    image_family: freebsd-13-2
+  setup_script:
+    - pkg update
+    - pkg install -y pkgconf git sdl2 python fontconfig opus
+    - git submodule update --init --recursive
+  test_script:
+    - ./scripts/cirrus/build_freebsd.sh dedicated
+    - ./scripts/cirrus/build_freebsd.sh full
+
+task:
+  name: freebsd-14-amd64
+  freebsd_instance:
+    image_family: freebsd-14-0-snap
+  setup_script:
+    - pkg update
+    - pkg install -y pkgconf git sdl2 python fontconfig opus
+    - git submodule update --init --recursive
+  test_script:
+    - ./scripts/cirrus/build_freebsd.sh dedicated
+    - ./scripts/cirrus/build_freebsd.sh full
+
+task:
+  name: freebsd-15-amd64
+  freebsd_instance:
+    image_family: freebsd-15-0-snap
+  setup_script:
+    - pkg update
+    - pkg install -y pkgconf git sdl2 python fontconfig opus
+    - git submodule update --init --recursive
+  test_script:
+    - ./scripts/cirrus/build_freebsd.sh dedicated
+    - ./scripts/cirrus/build_freebsd.sh full

.editorconfig

@@ -0,0 +1,9 @@
+# EditorConfig is awesome: https://EditorConfig.org
+root = true
+
+[*]
+charset = latin1
+end_of_line = lf
+indent_style = tab
+insert_final_newline = true
+trim_trailing_whitespace = true

.gitattributes

@@ -0,0 +1,3 @@
+*.c	text eol=lf diff=cpp
+*.h	text eol=lf diff=cpp
+wscript text eol=lf diff=python

.github/workflows/c-cpp.yml

@@ -0,0 +1,128 @@
+name: Build & Deploy Engine
+on: [push, pull_request]
+jobs:
+#  cleanup:
+#    runs-on: self-hosted
+#    steps:
+#    - name: Cleanup
+#      run: rm -rf .* || true
+  build:
+    runs-on: ${{ matrix.os }}
+    continue-on-error: true
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Linux build specifically want oldest Ubuntu as possible
+          # to be crossdistribution compatible, otherwise use ubuntu-latest
+          - os: ubuntu-20.04
+            targetos: linux
+            targetarch: amd64
+          - os: ubuntu-20.04
+            targetos: linux
+            targetarch: i386
+#          - os: ubuntu-aarch64-20.04
+#            targetos: linux
+#            targetarch: aarch64
+
+#          - os: ubuntu-20.04
+#            targetos: android
+#            targetarch: 32
+#          - os: ubuntu-20.04
+#            targetos: android
+#            targetarch: 64
+
+#          - os: ubuntu-20.04
+#            targetos: motomagx
+#            targetarch: armv6
+
+          - os: ubuntu-latest
+            targetos: nswitch
+            targetarch: arm64
+          - os: ubuntu-latest
+            targetos: psvita
+            targetarch: armv7hf
+          - os: windows-latest
+            targetos: win32
+            targetarch: amd64
+          - os: windows-latest
+            targetos: win32
+            targetarch: i386
+    env:
+      SDL_VERSION: 2.28.1
+      GH_CPU_ARCH: ${{ matrix.targetarch }}
+      ANDROID_SDK_TOOLS_VER: 4333796
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+      with:
+        submodules: recursive
+    - name: Install dependencies
+      run: bash scripts/gha/deps_${{ matrix.targetos }}.sh
+    - name: Build engine
+      run: bash scripts/gha/build_${{ matrix.targetos }}.sh
+    - name: Upload engine (artifacts)
+      uses: actions/upload-artifact@v3
+      with:
+        name: artifact-${{ matrix.targetos }}-${{ matrix.targetarch }}
+        path: artifacts/*
+  flatpak:
+    name: "Flatpak"
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - app: su.xash.Engine.Compat.i386
+    container:
+      image: bilelmoussaoui/flatpak-github-actions:freedesktop-22.08
+      options: --privileged
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+      with:
+        submodules: recursive
+    - name: Build flatpak (Compat.i386)
+      uses: FWGS/flatpak-github-actions/flatpak-builder@v6.1
+      with:
+        bundle: ${{ matrix.app }}.flatpak
+        manifest-path: scripts/flatpak/${{ matrix.app }}.yml
+    - name: Upload engine (artifacts)
+      uses: actions/upload-artifact@v3
+      with:
+        name: artifact-${{ matrix.targetos }}-${{ matrix.targetarch }}
+        path: artifacts/*
+  release:
+    name: "Upload releases"
+    runs-on: ubuntu-latest
+    needs: [build, flatpak]
+    if: ${{ github.event_name == 'push' }}
+    steps:
+    - name: Remove old release
+      uses: FWGS/delete-tag-and-release@v0.2.1-dev
+      with:
+        tag_name: ${{ github.ref_name == 'master' && 'continuous' || format('continuous-{0}', github.ref_name) }}
+        delete_release: true
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+    - name: Fetch artifacts
+      uses: actions/download-artifact@v3.0.1
+      with:
+        path: artifacts/
+    - name: Repackage binaries and allow GitHub to process removed release for few seconds
+      run: |
+        cd artifacts/
+        for i in artifact-* su.xash.Engine.*; do
+          mv "$i"/* .
+          rm -rf "$i"
+        done
+        ls -R .
+        cd ../
+        sleep 20s
+    - name: Upload new release
+      uses: FWGS/action-gh-release@v0.1.15
+      with:
+        name: Xash3D FWGS Continuous ${{ github.ref_name }} Build
+        tag_name: ${{ github.ref_name == 'master' && 'continuous' || format('continuous-{0}', github.ref_name) }}
+        prerelease: true
+        token: ${{ secrets.GITHUB_TOKEN }}
+        files: artifacts/*
+        draft: false

.gitignore

@@ -0,0 +1,339 @@
+# Binaries
+*.o
+*.so
+*.a
+*.framework
+
+# Other
+*.save
+
+# Qt Creator for some reason creates *.user.$version files, so exclude it too
+*.user*
+*~
+
+### Xcode ###
+build/
+*.pbxuser
+!default.pbxuser
+*.mode1v3
+!default.mode1v3
+*.mode2v3
+!default.mode2v3
+*.perspectivev3
+!default.perspectivev3
+xcuserdata
+*.xccheckout
+*.moved-aside
+DerivedData
+*.xcuserstate
+
+
+### OSX ###
+.DS_Store
+.AppleDouble
+.LSOverride
+
+
+# Thumbnails
+._*
+
+# Files that might appear on external disk
+.Spotlight-V100
+.Trashes
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### CMake ###
+CMakeCache.txt
+CMakeFiles
+Makefile
+cmake_install.cmake
+install_manifest.txt
+# makedepend
+Makefile.dep
+*.bak
+ALL_BUILD.*
+INSTALL.*
+ZERO_CHECK.*
+CMakeLists.txt
+
+# Visual Studio
+*.obj
+*.dll
+*.exp
+*.lib
+*.suo
+*.sdf
+Debug/
+Release/
+ipch/
+*.opensdf
+# Use CMake for generating projects
+*.vcxproj.filters
+*.vcxproj
+*.sln
+
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+build/
+bld/
+[Bb]in/
+[Oo]bj/
+
+# Visual Studio 2015 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# DNX
+project.lock.json
+artifacts/
+
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opensdf
+*.sdf
+*.cachefile
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding add-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# TODO: Comment the next line if you want to checkin your web deploy settings 
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/packages/*
+# except build/, which is used as an MSBuild target.
+!**/packages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/packages/repositories.config
+
+# Windows Azure Build Output
+csx/
+*.build.csdef
+
+# Windows Store app package directory
+AppPackages/
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!*.[Cc]ache/
+
+# Others
+ClientBin/
+[Ss]tyle[Cc]op.*
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.pfx
+*.publishsettings
+node_modules/
+orleans.codegen.cs
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+
+# SQL Server files
+*.mdf
+*.ldf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# PVS Studio for Linux output
+*.cl.cfg
+
+# Kate
+*.kate-swp
+*.swp
+
+# QtCreator
+build-*
+
+# Android
+*.apk
+*.config
+*.creator
+*.includes
+*.files
+
+# Waf
+build_current
+*waf-*/
+*waf3-*/
+.lock-waf*
+*.lastbuildstate
+*.unsuccessfulbuild
+__pycache__
+*.pyc
+
+# MSVC projects
+*.vcproj
+*.sln
+*.vcxproj
+
+# Visual Studio Code
+.vscode/*
+*.code-workspace
+.history/*
+.cache/*
+enc_temp_folder/
+
+# KDevelop4
+*.kdev4

.gitmodules

@@ -0,0 +1,21 @@
+[submodule "mainui"]
+	path = 3rdparty/mainui
+	url = https://github.com/FWGS/mainui_cpp
+[submodule "ref_gl/nanogl"]
+	path = 3rdparty/nanogl
+	url = https://github.com/FWGS/nanogl
+[submodule "ref_gl/gl-wes-v2"]
+	path = 3rdparty/gl-wes-v2
+	url = https://github.com/FWGS/gl-wes-v2
+[submodule "ref_gl/gl4es"]
+	path = 3rdparty/gl4es/gl4es
+	url = https://github.com/ptitSeb/gl4es
+[submodule "vgui_support"]
+	path = 3rdparty/vgui_support
+	url = https://github.com/FWGS/vgui_support
+[submodule "opus"]
+	path = 3rdparty/opus/opus
+	url = https://github.com/xiph/opus
+[submodule "3rdparty/xash-extras"]
+	path = 3rdparty/extras/xash-extras
+	url = https://github.com/FWGS/xash-extras

3rdparty/extras/wscript

@@ -0,0 +1,29 @@
+#! /usr/bin/env python
+# encoding: utf-8
+
+import os
+
+def options(opt):
+	pass
+
+def configure(conf):
+	if not conf.path.find_dir('xash-extras'):
+		conf.fatal('Can\'t find xash-extras submodule.')
+		return
+
+	conf.load('zip')
+
+def build(bld):
+	srcdir = bld.path.find_dir('xash-extras')
+
+	if bld.env.DEST_OS in ['android']:
+		install_path = bld.env.PREFIX
+	else:
+		install_path = os.path.join(bld.env.SHAREDIR, bld.env.GAMEDIR)
+
+	bld(features='zip',
+		name = 'extras.pk3',
+		files = srcdir.ant_glob('**/*'),
+		relative_to = srcdir,
+		compresslevel = 0,
+		install_path = install_path)

3rdparty/gl4es/wscript

@@ -0,0 +1,24 @@
+#! /usr/bin/env python
+# encoding: utf-8
+
+import os
+
+def options(opt):
+	pass
+
+def configure(conf):
+	if not conf.path.find_dir('gl4es') or not conf.path.find_dir('gl4es/src'):
+		conf.fatal('Can\'t find gl4es submodule. Run `git submodule update --init --recursive`.')
+		return
+
+def build(bld):
+	gl4es_srcdir = bld.path.find_node('gl4es/src')
+
+	bld.stlib(source   = gl4es_srcdir.ant_glob(['gl/*.c', 'gl/*/*.c', 'glx/hardext.c']),
+		target   = 'gl4es',
+		features = 'c',
+		includes = ['gl4es/src', 'gl4es/src/gl', 'gl4es/src/glx', 'gl4es/include'],
+		defines  = ['NOX11', 'NO_GBM', 'NO_INIT_CONSTRUCTOR', 'DEFAULT_ES=2', 'NOEGL', 'EXTERNAL_GETPROCADDRESS=GL4ES_GetProcAddress', 'NO_LOADER', 'STATICLIB'],
+		cflags   = ['-w', '-fvisibility=hidden', '-std=gnu99'],
+		subsystem = bld.env.MSVC_SUBSYSTEM,
+		export_includes = '.')

3rdparty/opus/wscript

@@ -0,0 +1,40 @@
+#! /usr/bin/env python
+# encoding: utf-8
+
+import os
+
+def options(opt):
+	pass
+
+def configure(conf):
+	if not conf.path.find_dir('opus') or not conf.path.find_dir('opus/src'):
+		conf.fatal('Can\'t find opus submodule. Run `git submodule update --init --recursive`.')
+		return
+
+	# TODO: ARM/x86 intrinsics detection
+	# TODO: maybe call autotools/cmake/meson instead?
+
+def build(bld):
+	sources = bld.path.ant_glob([
+		'opus/src/*.c',
+		'opus/celt/*.c',
+		'opus/silk/*.c',
+		'opus/silk/float/*.c'
+	], excl = [
+		'opus/src/repacketizer_demo.c',
+		'opus/src/opus_demo.c',
+		'opus/src/opus_compare.c',
+		'opus/celt/opus_custom_demo.c'
+	])
+	includes = ['opus/include/', 'opus/celt/', 'opus/silk/', 'opus/silk/float/']
+	defines = ['USE_ALLOCA', 'OPUS_BUILD', 'FLOAT_APPROX', 'PACKAGE_VERSION="1.3.1"', 'CUSTOM_MODES']
+
+	bld.stlib(
+		source = sources,
+		target = 'opus',
+		features = 'c',
+		includes = includes,
+		defines = defines,
+		subsystem = bld.env.MSVC_SUBSYSTEM,
+		export_includes = ['opus/include/']
+	)

CONTRIBUTING.md

@@ -0,0 +1,47 @@
+## If you are reporting bugs
+
+1. Check you are using latest version. You can build latest Xash3D FWGS for yourself, look to README.md.
+2. Check open issues is your bug is already reported and closed issues if it reported and fixed. Don't send bug if it's already reported.
+3. Re-run engine with `-dev 2 -log` arguments, reproduce bug and post engine.log which can be found in your working directory.
+3. Describe steps to reproduce bug.
+4. Describe which OS and architecture you are using.
+6. Attach screenshot if it will help clarify the situation.
+
+## If you are contributing code
+
+### Which branch?
+
+* We recommend using `master` branch.
+
+### Third-party libraries
+
+* Philosophy of any Xash Project by Uncle Mike: don't be bloated. We follow it too.
+* Adding new library is allowed only if there is a REAL reason to use it. It's will be nice, if you will leave a possibility to remove new dependency at build-time.
+* Adding new dependencies for Waf Build System is not welcomed.
+
+### Portability level
+
+* Xash3D have it's own crt library. It's recommended to use it. It most cases it's just a wrappers around standart C library.
+* If your feature need platform-specific code, move it to `engine/platform` and try to implement to every supported OS and every supported compiler or at least leave a stubs.
+* You must put it under appopriate macro. It's a rule: Xash3D FWGS must compile everywhere. For list of platforms we support, refer to public/build.h file.
+
+### Code style
+
+* This project uses mixed Quake's and HLSDK's C/C++ code style convention. 
+* In short:
+  * Use spaces in parenthesis.
+  * Only tabs for indentation.
+  * Any brace must have it's own line.
+  * Short blocks, if statements and loops on single line are allowed.
+  * Avoid magic numbers.
+  * While macros are powerful, it's better to avoid overusing them.
+  * If you unsure, try to mimic code style from anywhere else of engine source code.
+* **ANY** commit message should start from declaring a tags, in format:
+  
+  `tag: added some bugs`
+  
+  `tag: subtag: fixed some features`
+  
+  Tags can be any: subsystem, simple feature name or even just a filename, without extension.
+  Just keep them always same, it helps keep history clean and commit messages short.
+

Documentation/bug-compatibility.md

@@ -0,0 +1,17 @@
+# Bug-compatibility in Xash3D FWGS
+
+Xash3D FWGS has special mode for games that rely on original engine bugs.
+
+In this mode, we emulate the behaviour of selected functions that may help running mods relying on engine bugs, but enabling them by default may break majority of other games.
+
+At this time, we only have implemented GoldSrc bug-compatibility. It can be enabled with `-bugcomp` command line switch.
+
+## GoldSrc bug-compatibility
+
+### Emulated bugs
+
+* `pfnPEntityOfEntIndex` in GoldSrc returns NULL for last player due to incorrect player index comparison
+
+### Games and mods that require this
+
+* Counter-Strike: Condition Zero - Deleted Scenes

Documentation/cross-compiling-for-windows-with-wine.md

@@ -0,0 +1,9 @@
+# Cross-compiling for Windows with Wine
+
+This can be useful to test engine in Wine without using virtual machines or dual-booting to Windows.
+
+0. Clone and install https://github.com/mstorsjo/msvc-wine (you can skip CMake part)
+1. Set environment variable MSVC_WINE_PATH to the path to installed MSVC toolchain
+2. Pre-load wine: `wineserver -k; wineserver -p; wine64 wineboot`
+3. Run `./waf configure -T <build-type> --enable-wine-msvc --sdl2=../SDL2_VC`. Configuration step will take more time than usual.
+4. .. other typical steps to build from console ...

Documentation/debugging-using-minidumps.md

@@ -0,0 +1,10 @@
+# Debugging your mod using minidump files (Windows only)
+Minidump files is awesome instrument for debugging your mod after it's being released, or for catch specific crashes which are presented only in one specific configuration, but doesn't happens in other configurations or even on developer machine. It contains a lot of information useful for debugging, and therefore it size is not so small: around hundreds or even thousands of megabytes. But this is not a problem, since minidump files compresses very effectively using common algorithms.
+There are short algorithm, explaining how to use this debugging instrument:
+
+1. User starts your mod with `-minidumps` startup parameter
+2. Finally, crash happened on user's machine, and minidump file being written. This file has `.mdmp` extension and located in same folder, where mod folder located
+3. User packs this minidump file to .zip/.7z archive, and somehow sends it to developer
+4. Developer just opens minidump file in Visual Studio, then a virtual debugging session is opened and now reasons of crash is pretty easy to detect: you can see call stack, local function variables and global variables, information about exception and a lot of other information
+
+You can find more information about minidumps in this [awesome article](https://learn.microsoft.com/en-us/windows/win32/dxtecharts/crash-dump-analysis?source=recommendations#writing-a-minidump).

Documentation/donate.md

@@ -0,0 +1,24 @@
+# Developers donation page
+
+On this page you can find links where you can support each developer individually, who has provided public sponsorship information.
+
+### [a1batross](https://github.com/a1batross)
+
+* Initial Xash3D SDL2/Linux port author, Xash3D FWGS engine maintainer, creator of non-commercial Flying With Gauss organization.
+* Boosty page: https://boosty.to/a1ba
+
+### [nekonomicon](https://github.com/nekonomicon)
+
+* [hlsdk-portable](https://github.com/FWGS/hlsdk-portable), [mdldec](../utils/mdldec), [opensource-mods.md](opensource-mods.md) maintainer and Xash3D FWGS [contributor](https://github.com/FWGS/xash3d-fwgs/commits?author=nekonomicon) (*BSD/clang port, PNG support, etc).
+* Boosty page: https://boosty.to/nekonomicon
+
+### [Velaron](https://github.com/Velaron)
+* [cs16-client](https://github.com/Velaron/cs16-client) & [tf15-client](https://github.com/Velaron/tf15-client) maintainer and Xash3D FWGS [contributor](https://github.com/FWGS/xash3d-fwgs/commits?author=Velaron) (Android port, voice chat, etc).
+* BuyMeACoffee page: https://www.buymeacoffee.com/velaron
+
+### [SNMetamorph](https://github.com/SNMetamorph)
+* [PrimeXT](https://github.com/SNMetamorph/PrimeXT) & [GoldSrc Monitor](https://github.com/SNMetamorph/goldsrc-monitor) maintainer and Xash3D FWGS [contributor](https://github.com/FWGS/xash3d-fwgs/commits?author=SNMetamorph) (Windows port, voice chat, etc).
+* BTC: `16GAzK3qei5AwBW7sggXp3yNcFHBtdpxXj`
+* ETH (ERC20): `0xb580eeca9756e3881f9d6d026e28db28eb72a383`
+* USDT (ERC20): `0xb580eeca9756e3881f9d6d026e28db28eb72a383`
+* USDC (ERC20): `0xb580eeca9756e3881f9d6d026e28db28eb72a383`

Documentation/engine-porting-guide.md

@@ -0,0 +1,71 @@
+## Abstract
+
+Before start, I would recommend you to compile and run engine for already supported and well-spread platform, such as GNU/Linux or Windows. Hack it, get familiar with engine.
+
+One beauties of Xash3D FWGS Engine is it modularity, so game logic, UI and renderers are located in platform-independent libraries. Every library is loaded at run time and may or may be not optional.  For example, if your platform doesn't have OpenGL of any kind, you can skip it and use our software renderer! Of course, there is no real reason to run game engine, if you don't have game logic of any kind, so the minimal build of Xash3D FWGS is headless dedicated server.
+
+Historically, Xash3D Engine was even more modular(see github.com/a1batross/Xash3D_ancient), but we thought that to fulfill our crossplatform needs we will keep all platform-specific stuff in the engine itself and libraries must import or expose platform-independent APIs.
+
+Ok, get to the point!
+
+## Porting guidelines
+
+It will not be a complete tutorial as covering everything in one article is probably just impossible. Instead, I will give you hints on how engine can be ported, how to get your port to upstreamed and how you should maintain your port.
+
+0) Get to know your platform. Maybe I asked for this lately, but you MUST KNOW YOUR PLATFORM, i.e. what's this capable of.
+
+The one of unsupported configurations at this time is when platform can't load dynamic libraries(`*.so` or DLLs). We can't help you as supporting full-static ports are violating the GPL license in various ways.
+
+The other yet unsupported configuration is the big endian.
+
+1) Setup toolchain. For dirty port, you can write Makefile for yourself, engine is written that way, so **it doesn't relies** on any generated data or any special processing. But I recommend you to use Waf anyway, it's better integrated to engine and self-documentable. Also, I will cover only our Waf build options.
+
+2) Open `public/build.h` file. Add appropriate checks for your operating system and/or CPU architecture. It shouldn't be hard.
+
+Also, you'll need to build [Half-Life SDK](https://github.com/FWGS/hlsdk-xash3d/). It has same `public/build.h` so reflect changes into it. Note that to be compatible with HLSDK proprietary license, it's relicensed as public domain under [Unlicense](https://unlicense.org).
+
+We have a library naming scheme that allows us and game creators to distribute binaries for different platforms in one archive. Read `Documentation/extensions/library-naming.md` for more information.
+
+In short, you need to call your platform in unique way. For engine side it's done in `engine/common/build.c` file in engine source code, for HLSDK side it's done in `cmake/LibraryNaming.cmake` and `scripts/waifulib/library-naming.py` files in HLSDK source code.
+
+You can use [predef project wiki](https://sourceforge.net/p/predef/wiki/Home/) for reference.
+
+2) Look at the `engine/platform` directory. We usually try to have all platform-specific stuff inside this folder.
+
+* Functions that must be available on your platform are declared in `platform.h` header. Most of them aren't used in headless dedicated build, but I will cover that later.
+
+* The POSIX-compliant(for *nix operating systems) goes into `posix` subdirectory.
+
+* The SDL-specific code goes into `sdl` subdirectory. Note that even I said before that platform-specific code is in `platform` directory, SDL obviously isn't a __platform__, so you can met checks for XASH_SDL inside whole engine, usually in input.
+
+* Custom SWAP implementation for *nix-based systems is in `swap` subdirectory. It's used when hardware may not have enough memory and you can't add swap memory. I will cover that later
+It relies on a fact that systems with paged memory will load pages into RAM and move unused to mmap()-ed by custom swap area.
+That allowed to run game engine on music player with MIPS CPU, Linux without SWAP support and
+
+* Other folders as `win32`, `android`, `linux` and so on are self-descriptive.
+
+3) As proof of concept, you can try to test that network features and dynamic library loading are implemented correctly. Build a dedicated server with XASH_DEDICATED or `--dedicated` passed  to `waf configure`.
+
+Start a server and try to connect to it from PC. If everything is fine, then you can move to next step.
+
+If you get out of memory issues, you can try Low Memory Mode, it's enabled with `--low-memory-mode=N` passed to `waf configure` where N is 1 or 2. Low Memory Mode 1 means that we will NOT break a network compatibility. 2 is deeper and doesn't guarantee protocol compatibility and available multiplayer. Of course, with Low Memory Mode 2 you can't test your port dedicated server.
+
+If you got anything compiling, it's nice time to make a commit. Commit your changes into git and push them somewhere(GitHub, GitLab or what you prefer), so you will not lose them accidentally.
+
+4) Here is most interesting, building the client part.
+
+There are three possible situations for you, by increasing difficulty.
+
+1. Do you have SDL2 for your platform? If yes, go ahead and compile engine with client part enabled.
+
+2. Do you have SDL1.2 for your platform? If yes, try to compile it, but SDL1.2 support is very limited and not tested well.
+
+3. You don't have SDL and you can't port it for some reason by yourself or SDL port just don't stable for your platform? Then you need to implement an engine backend.
+
+How to implement engine backend? Well, we have a backends system that was introduced in Old Engine. It's simply two files: backends.h and defaults.h in `common` folder in repository root. You will need to add a macros for your backends in `backends.h` and define a logic in `defaults.h`. We have already have some, check them out, as they may be handy for you.
+
+Once you did it, go back to `platform` directory and open `platform.h` headers. Create new subdirectory in `platform` folder and start implementing missing platform-specific backends one by one. I can't explain this as for obvious reasons it's too specific. You can use macros you defined before in `build.h` to check that you're compiling for your platform and `backends.h` macros to check if platform-specific backend must be enabled.
+
+As you finished, compile engine, fix errors and commit your changes and push to repository.
+
+Remember, if something doesn't work and you can't figure out why, you can join our Discord server at discord.me/fwgs. Ping me (@a1batross) or other engine developer and attach link to your repository, so we can discuss and help you in porting.

Documentation/entity-tools.md

@@ -0,0 +1,150 @@
+# There are few new commands availiable in xash3d fork:
+
+## Commands:
+### ent_create
+Create entity with specified classname and key/values
+
+`ent_create <classname> <key> <value> <key> <value> ...`
+
+for example:
+
+`ent_create monster_zombie targetname zomb1`
+
+after creating entity, ent_last_xxx cvars are set to new entity and ent_last_cb called, look at ent_getvars description
+
+### ent_fire
+
+Make some actions on entity
+
+`ent_fire <pattern> <command> <args>`
+Availiavle commands:
+* Set fields (Only set entity field, does not call any functions):
+   * health
+   * gravity
+   * movetype
+   * solid
+   * rendermode
+   * rendercolor (vector)
+   * renderfx
+   * renderamt
+   * hullmin (vector)
+   * hullmax (vector)
+* Actions
+   * rename: set entity targetname
+   * settarget: set entity target (only targetnames)
+   * setmodel: set entity model (does not update)
+   * set: set key/value by server library
+       * See game FGD to get list.
+       * command takes two arguments
+   * touch: touch entity by current player.
+   * use: use entity by current player.
+   * movehere: place entity in player fov.
+   * drop2floor: place entity to nearest floor surface
+   * moveup: move entity to 25 units up
+   * moveup (value): move by y axis relatively to specified value
+* Flags (Set/clear specified flag bit, arg is bit number):
+   * setflag
+   * clearflag
+   * setspawnflag
+   * clearspawnflag
+
+### ent_info
+Print information about entity by identificator
+
+`ent_info <identificator>`
+
+### ent_getvars
+Set client cvars containing entity information (useful for [[Scripting]]) and call ent_last_cb
+
+`ent_getvars <identificator>`
+
+These cvars are set:
+```
+ent_last_name
+ent_last_num
+ent_last_inst
+ent_last_origin
+ent_last_class
+```
+
+### ent_list
+Print short information about antities, filtered by pattern
+
+`ent_list <pattern>`
+
+## Syntax description
+
+### \<identificator\>
+
+* !cross: entity under aim
+* Instance code: !\<number\>_\<seria\l>
+ * set by ent_getvars command
+* Entity index
+* targetname pattern
+
+### \<pattern\>
+
+Pattern is like identificator, but may filter many entities by classname
+
+### (vector)
+
+used by ent_fire command. vector means three float values, entered without quotes
+
+### key/value
+
+All entities parameters may be set by specifiing key and value strings.
+
+Originally, this mechanizm is used in map/bsp format, but it can be used in enttools too.
+
+Keys and values are passed to server library and processed by entity keyvalue function, setting edict and entity owns parameters.
+
+If value contains spaces, it must be put in quotes:
+
+`ent_fire !cross set origin "0 0 0"`
+
+## Using with scripting
+
+ent_create and ent_getvars commands are setting cvars on client
+
+It can be used with ent_last_cb alias that is executed after setting cvars.
+
+Simple example:
+
+```
+ent_create weapon_c4
+alias ent_last_cb "ent_fire \$ent_last_inst use"
+```
+
+Use weapon_c4 after creating it.
+
+Note that you cannot use many dfferent callbacks at the same time.
+
+You can set entity name by by pattern and create special script, contatning all callbacks.
+
+Example:
+
+example.cfg
+```
+alias ent_last_cb exec entity_cb.cfg
+ent create \<class\> targetname my_ent1_$name
+ent_create \<class\> targetname my_ent2_$name
+```
+entity_cb.cfg
+```
+if $ent_last_name == my_ent1_$name
+:(ent1 actions)
+if $ent_last_name == my_ent2_$name
+:(ent2 actions)
+```
+Note that scripting cannot be blocking. You cannot wait for server answer and continue. But you can use small scripts, connected with ent_last_cb command. The best usage is user interaction. You can add touch buttons to screen or call user command menu actions by callbacks.
+##  Server side
+
+To enable entity tools on server, set sv_enttools_enable to 1
+
+To change maximum number of entities, touched by ent_fire, change sv_enttools_maxfire to required number.
+
+To enable actions on players, set sv_enttools_players to 1.
+
+To enable entity tools for player by nickname, set sv_enttools_godplayer to nickname. Useful to temporary enable from rcon.
+
+To prevent crash on some actions, set host_mapdesign_fatal to 0

Documentation/extensions/console-scripting.md

@@ -0,0 +1,68 @@
+## Console variables
+
+Console variables (or CVars) are present in all quake-based games.
+
+By default, it is settings, created by engine, server or client libraries.
+
+But you can use `set` command to define variables even if they are not created by the engine.
+
+For example, you can set cvar before it is registered in code.
+
+`set defaultmap crossfire`
+
+This works even in server.cfg before server cvars initialization and the engine will reuse its value on cvar creation
+
+## Aliases
+
+An alias allows to define new commands.
+
+`alias wnext "invnext;wait;wait;+attack;wait;-attack"`
+
+You can hook any command by adding an alias to it and unaliasing it, when you want to use original command.
+
+```
+alias invnext1 "unalias invnext;wnext;alias invnext invnext1"
+alias invnext invnext1
+```
+
+## Scripting extensions
+
+This is an extensions of Xash3D FWGS(merged to original Xash3D since build 3887), that can be enabled by cmd_scripting cvar.
+
+Enabling scripting: `cmd_scripting 1`
+
+This is an archive cvar and it will be saved.
+
+### CVar substitution
+
+You can substitute cvar value to any command by adding \$ symbol:
+
+`echo $sv_cheats`
+
+### Condition checking
+
+Allows checking cvar values.
+
+```
+if <value1> <operator> <value2>
+:<action1>
+:if <value3>
+::<action2>
+:<action3>
+else
+:<action4>
+```
+
+* Values are any string or numeric values (for example, substituted cvars).
+* Operator is = (or ==), \!=, \<, \>, \<=, \>=. == is same to =.
+* If single value specified, condition is true when value is non-zero
+
+Example:
+
+```
+if $sv_cheats == 1
+:echo Cheats enabled, adding cheat menu
+:exec cheatmenu.cfg
+else
+:echo Please enable cheats to use this!
+```

Documentation/extensions/expanded-common-structures.md

@@ -0,0 +1,8 @@
+# Expanded structures that used by engine and mods
+To make porting and developing mods on 64-bit platforms less painful, we decided to expand size of several structures.
+This information important in case you are using codebase like XashXT, Paranoia 2: Savior and want to compile your mod for platform with 64-bit pointer size: you should replace old definitions with new ones, otherwise your mod will not work with Xash3D FWGS (typically, it's just crashing when starting map).
+| Structure name | Locates in file | Original size on 64-bit | Current size on 64-bit |
+|----------------|-----------------|-------------------------|------------------------|
+|`mfaceinfo_t` | `common/com_model.h` | 176 bytes |  304 bytes |
+|`decal_s` | `common/com_model.h` | 72 bytes |  88 bytes |
+|`mextrasurf_t` | `common/com_model.h` | 376 bytes |  504 bytes |

Documentation/extensions/input-interface-ru.md

@@ -0,0 +1,48 @@
+## Цель
+
+На текущий момент клиенты имеют некоторые части платформозависимого кода внутри себя. Это плохо, т.к. мы не можем использовать одинаковые функции (если не перепишем почти половину кода SDL) на разных платформах.
+
+## Клиентская часть
+
+* Клиент будет иметь возможность полностью реализовать touch-ввод. Отрисовка может быть произведена через HUD.
+* Клиент получит простые события движения и обзора от движка
+
+### Клиентская реализация
+
+#### Клиент будет экспортировать некоторые функции движку (опционально):
+
+* `int IN_ClientTouchEvent ( int fingerID, float x, float y, float dx, float dy );`
+
+Вернёт 1 если касание активно, иначе 0.
+
+* `void IN_ClientMoveEvent ( float forwardmove, float sidemove );`
+
+Клиент будет накапливать значения величин для команд движения перед созданием команд и очищать их при CreateMove.
+
+* `void IN_ClientLookEvent ( float relyaw, float relpitch );`
+
+Клиент будет вращать камерой когда нужно, прямо как в реализации мыши
+
+## Движковая часть
+
+* Движок будет управлять событиями платформы и вызывать клиентские функции
+* Движок реализует стандартную систему взгляда и движения если её нет в клиенте
+
+### Движковая реализация
+
+#### События касания
+
+Перед вызовом ClientMove движок обязан получить события о касании.
+
+Если из клиента экспортирована функция IN_ClientTouchEvent, событие будет отправлено клиенту.
+
+Иначе, движок будет рисовать свой touch-интерфейс.
+
+#### Другие события
+
+Интерфейс прикосновений и код джойстика в движке будут генерировать следующие два типа событий:
+* События движения (функция IN_ClientMoveEvent)
+* События просмотра (функция IN_ClientLookEvent)
+
+Если клиент экспортирует эти функции, события будут отправляться клиенту перед CreateMove
+Иначе события просмотра будут происходить перед CreateMove, но после MoveEvent. Они будут применены к генерируемым командам

Documentation/extensions/input-interface.md

@@ -0,0 +1,48 @@
+## Purpose
+
+Clients have different platform-depended input code now.
+It is bad because we cannot use same functions (if we won't rewrite almost half of SDL) on different platforms.
+
+## Client part
+
+* Client will have ability to fully implement touch input. Drawing may be done by HUD.
+* Client will receive basic motion and look events from engine
+
+### Client implementation
+
+#### Client will optionally export some functions to Engine:
+* `int IN_ClientTouchEvent ( int fingerID, float x, float y, float dx, float dy );`
+
+Return 1 if touch is active, 0 otherwise.
+
+* `void IN_ClientMoveEvent ( float forwardmove, float sidemove );`
+
+Client wil accumulate move values before creating commands and flush it on CreateMove.
+
+* `void IN_ClientLookEvent ( float relyaw, float relpitch );`
+
+Client will rotate camera when needed as in mouse implementation
+
+## Engine part
+
+* Engine will handle platform events and call client functions.
+* Engine will implement fallback look and movement system when client interface not present
+
+### Engine implementation
+
+#### Touch events
+
+Before calling ClientMove engine must get touch events.
+
+If client exported IN_ClientTouchEvent, event will be sent to client.
+
+Otherwise engine will draw own touch interface.
+
+#### Other events
+
+Engine touch interface and joystick support code will generate two types of events:
+* Move events (IN_ClientMoveEvent function)
+* Look events (IN_ClientLookEvent function)
+
+If client exported these functions, events will be sent to client before CreateMove
+Otherwise Look Event will be processed before CreateMove, but MoveEvent after. It will be applied to generated command

Documentation/extensions/library-naming.md

@@ -0,0 +1,44 @@
+I propose a new library naming scheme, which will allow to distribute mods and games in single archive to different operating systems and CPUs:
+
+Legend:
+* $os -- Q_buildos() return value, in lower case.
+* $arch -- Q_buildarch() return value, in lower case.
+* $ext -- OS-specific extension: dll, so, dylib, etc.
+
+The scheme will be:
+
+1. Client library:
+* ```client.$ext``` for **Win/Lin/Mac** with **x86**.
+* ```client_$arch.$ext``` for **Win/Lin/Mac** with **NON-x86**.
+* ```client_$os_$arch.$ext``` for everything else.
+
+2. Menu library:
+* ```menu.$ext``` for **Win/Lin/Mac** with **x86**.
+* ```menu_$arch.$ext``` for **Win/Lin/Mac** with **NON-x86**.
+* ```menu_$os_$arch.$ext``` for everything else.
+
+3. Server library:
+* On  **Win/Lin/Mac** with **x86**, it **MUST** use the raw gamedll name for corresponding OS field from `gameinfo.txt`.
+* On **Win/Lin/Mac** with **NON-x86**, it **MUST** use the raw gamedll name for corresponding OS field from `gameinfo.txt`, but append ```_$arch``` before file extension. Like: ```hl_amd64.so``` or ```cs_e2k.so```.
+* On everything else, it must use gamedll name from ```gamedll_linux``` field, but append ```_$os_$arch``` before file extension. Like: ```hl_haiku_amd64.so``` or ```cs_freebsd_armhf.so```.
+Why ```gamedll_linux``` and not ```gamedll```? Because it looks more logic that way, most operating systems are *nix-like and share code with Linux, rather than Windows.
+
+4. Refresh library: not needed, as RefAPI is not stable and it's not intended to distribute with mods.
+
+For any libraries distributed **with** engine, naming scheme should be used more convenient for OS port.
+
+Issue #0. Inconsistency between ABI and Q_buildarch.\
+Resolution: Change Q_buildarch return value to use Debian-styled architectures list: https://www.debian.org/ports/, which includes a special naming for big/little-endian and hard/soft-float ARM.
+
+Issue #1: Build-system integration.\
+Resolution: implemented as [LibraryNaming.cmake](https://github.com/FWGS/hlsdk-portable/blob/master/cmake/LibraryNaming.cmake) and [library_naming.py](https://github.com/FWGS/hlsdk-portable/blob/master/scripts/waifulib/library_naming.py) extensions, see 
+
+Issue #2(related to #0): Which ARM flavours we actually need to handle?\
+Resolution: Little-endian only, as there is no known big-endian ARM platforms in the wild.
+Architecture is coded this way:
+* ```armvxy```, where `x` is ARM instruction set level and `y` is hard-float ABI presence: `hf` where hard float ABI used, otherwise `l`.
+
+Issue #3: Some mods (like The Specialists, Tyrian, ...) already apply suffixes _i386, _i686 to the gamedll path:\
+Resolution: On x86 on **Win/Lin/Mac**, don't change anything. Otherwise, strip the _i?86 part and follow the usual scheme.
+
+See discussion: https://github.com/FWGS/xash3d-fwgs/issues/39

Documentation/extensions/mp3-loops.md

@@ -0,0 +1,22 @@
+## Looping MP3 extension
+
+It is now possible to loop MP3 file in Xash3D FWGS by adding a custom text tag with `LOOP_START` or `LOOPSTART` in description and time point (in raw samples) in value.
+
+### Example with foobar2000
+1. Open Foobar2000
+2. Add your .mp3 file to playlist
+3. Right click to newly added file and select Properties
+4. In Metadata tab, at the bottom of the table, select "+add new"
+5. In newly added line replace `<60>input field name<6D>` with `LOOP_START` (without any symbols).
+6. Press Tab and enter loop time point in raw samples. For example, `0` will replay sound file from beginning to end indefinitely.
+
+### Possible alternatives
+1. Classic WAV files looping. HQ WAV files can take too much disk space, and recommended software supporting cue points is paid, outdated and can't run on modern systems. (Although there is alternative that's proven to work with idTech-based engines called LoopAuditioneer.)
+2. Vorbis looping through comment. Engine doesn't support Vorbis but this extension was highly inspired by this hack.
+
+### Known bugs and limitations
+1. At this time using MP3 as SFX requires complete decoding. This can cause noticeable stutters, so keep MP3 file length in mind.
+2. We deliberately only support modern ID3v2.3 and ID3v2.4 tags. Using ID3v1 is not possible.
+
+
+

Documentation/gameinfo.md

@@ -0,0 +1,116 @@
+# Game definition and information file
+
+gameinfo.txt is an essential part of any Xash3D based game. It allows basic customization for games creators, like setting game title, DLL paths, etc.
+
+This document defines gameinfo.txt syntax, supported keys and liblist.gam conversion rules for the latest version of the engine. Note for engine developers, keep this document in sync with an implementation.
+
+## gameinfo.txt syntax
+
+* gameinfo.txt is a simple list of keys and values, separated by newline.
+* You can add single line comments using double slashes (//).
+* Keys can accept integer, float, string or boolean values.
+* Boolean keys use 0 as false and 1 as true value.
+* To have spaces in string values, you must enclose them in double quotes. Then, to have double quotes, you must escape it with backslash, and to have a backslash you need to use double backslashes.
+
+The example:
+```
+// this is a comment :)
+// this is another comment
+some_integer_key 123
+
+this_is_float_key 13.37 // optional comment
+
+enable_feature 1 // boolean, 1 to enable, 0 to disable
+
+example_string_key string_value
+example_spaces "string with spaces"
+example_title "Fate\\Stay Night" // engine will parse it as Fate\Stay Night
+```
+
+## gameinfo.txt keys
+
+This is a list of all gameinfo.txt keys supported by the engine. Be aware that the engine will silently skip all unrecognized keys.
+
+| Key              | Type       | Default value   | Description |
+| ---------------- | ---------- | --------------- | ----------- |
+| `ambient0`       | string     | Empty string    | Automatic ambient sound |
+| `ambient1`       | string     | Empty string    | Automatic ambient sound |
+| `ambient2`       | string     | Empty string    | Automatic ambient sound |
+| `ambient3`       | string     | Empty string    | Automatic ambient sound |
+| `basedir`        | string     | `valve`         | Game base directory, used to share assets between games |
+| `date`           | string     | Empty string    | Game release date. Unused. |
+| `dllpath`        | string     | `cl_dlls`       | Game DLL path. Engine will search custom DLLs (client or menu, for example) in this directory, except `gamedll`, see below. |
+| `fallback_dir`   | string     | Empty string    | Additional game base directory |
+| `gamedir`        | string     | Current gamedir | Game directory, ignored in FWGS, as game directory is defined by the game directory name |
+| `gamedll`        | string     | `dlls/hl.dll`   | Game server DLL for 32-bit x86 Windows (see LibraryNaming.md for details) |
+| `gamemode`       | string     | Empty string    | Game type. When set to `singleplayer_only` or `multiplayer_only` marks the game as SP or MP only respectively, hiding the option in game UI. Omitting this key or using custom values mark the game as both MP and SP compatible. |
+| `icon`           | string     | `game.ico`      | Game icon. Engine will automatically append .ico and may automatically switch to .tga icon as well |
+| `max_beams`      | integer    | 128             | Beams limit, 64 min, 512 max |
+| `max_edicts`     | integer    | 900             | Entities limit, 600 min, 8192 max (protocol limit). In FWGS, minimum is 64. |
+| `max_particles`  | integer    | 4096            | Particles limit, 1024 min, 131072 max |
+| `max_tempents`   | integer    | 500             | Temporary entities limit. 300 min, 2048 max |
+| `mp_entity`      | string     | `info_player_deathmatch` | Entity used to mark maps as multiplayer |
+| `mp_filter`      | string     | Empty string    | When set, used to filter multiplayer maps instead of `mp_entity`.<br>If the map name starts with the same characters as this filter, it's considered a multiplayer map |
+| `nomodels`       | boolean    | 0               | When set to 1, disallows changing player model in UI |
+| `noskills`       | boolean    | 0               | When set to 1, disallows selection of game difficulty |
+| `secure`         | boolean    | 0               | When set to 1, original Unkle Mike's engine will completely disable developer mode. FWGS ignores but preserves this value for compatibility. |
+| `size`           | integer    | 0               | Game directory size in bytes, used in Change Game dialog only |
+| `startmap`       | string     | `c0a0`          | The name of the map used in new game |
+| `sp_entity`      | string     | `info_player_start` | Entity used to mark map as single player. Used in map validation |
+| `title`          | string     | `New Game`      | Game title, used in window title, default server name, etc. |
+| `trainmap`       | string     | `t0a0`          | The name of the training map (Hazard Course) |
+| `type`           | string     | Empty string    | Game type, used in Change Game UI. |
+| `url_info`       | string     | Empty string    | Game homepage URL, used in Change Game UI |
+| `url_update`     | string     | Empty string    | Game updates URL, used in Settings UI |
+| `version`        | float      | 1.0             | Game version, used in Change Game dialog and in server info |
+
+## FWGS-specific gameinfo.txt keys
+
+These strings are specific to Xash3D FWGS.
+
+| Key                     | Type       | Default value            | Description |
+| ----------------------- | ---------- | ------------------------ | ----------- |
+| `animated_title`        | boolean    | 0                        | Use animated title in main menu (WON Half-Life logo.avi imitation from Half-Life 25-th anniversary update)
+| `autosave_aged_count`   | integer    | 2                        | Auto saves limit used in saves rotation |
+| `gamedll_linux`         | string     | Generated from `gamedll` | Game server DLL for 32-bit x86 Linux (see LibraryNaming.md for details) |
+| `gamedll_osx`           | string     | Generated from `gamedll` | Game server DLL for 32-bit x86 macOS (see LibraryNaming.md for details) |
+| `hd_background`         | boolean    | 0                        | Use HD background for main menu (Half-Life 25-th anniversary update) |
+| `internal_vgui_support` | boolean    | 0                        | Only for programmers! Required to be set as 1 for PrimeXT!<br>When set to 1, the engine will not load vgui_support DLL, as VGUI support is done (or intentionally ignored) on the game side. |
+| `render_picbutton_text` | boolean    | 0                        | When set to 1, the UI will not use prerendered `btns_main.bmp` and dynamically render them instead |
+| `quicksave_aged_count`  | integer    | 2                        | Quick saves limit used in saves rotation |
+
+## Note on GoldSrc liblist.gam support
+
+As Xash3D accidentally supports GoldSrc games, it also supports parsing liblist.gam.\
+Xash3D will use this file if gameinfo.txt is absent, or if its modification timestamp is older than liblist.gam.
+
+For game creators who plan supporting only Xash3D, using this file is not recommended.
+
+The table below defines conversion rules from liblist.gam to gameinfo.txt. Some keys' interpretation does differ from `gameinfo.txt`, in this case a note will be left. If `liblist.gam` key isn't present in this table, it's ignored.
+
+| `liblist.gam` key | `gameinfo.txt` key | Note |
+| ----------------- | ------------------ | ---- |
+| `animated_title`  | `animated_title`   |      |
+| `edicts`          | `max_edicts`       |      |
+| `fallback_dir`    | `fallback_dir`     |      |
+| `game`            | `title`            |      |
+| `gamedir`         | `gamedir`          |      |
+| `gamedll`         | `gamedll`          |      |
+| `gamedll_linux`   | `gamedll_linux`    |      |
+| `gamedll_osx`     | `gamedll_osx`      |      |
+| `hd_background`   | `hd_background`    |      |
+| `icon`            | `icon`             |      |
+| `mpentity`        | `mp_entity`        |      |
+| `mpfilter`        | `mp_filter`        |      |
+| `nomodels`        | `nomodels`         |      |
+| `secure`          | `secure`           | In GoldSrc it's used to mark the multiplayer game as anti-cheat enabled.<br>Original Xash3D misinterprets its value for disallowing console and developer mode.<br>FWGS ignores this key but preserves for compatibility. |
+| `startmap`        | `startmap`         |      |
+| `size`            | `size`             |      |
+| `trainingmap`     | `trainmap`         |      |
+| `trainmap`        | `trainmap`         |      |
+| `type`            | `type` & `gamemode`| In `liblist.gam` this key works as both `type` and `gamemode`.<br>If value is `singleplayer_only` or `multiplayer_only` the game is marked as SP or MP only, and `gameinfo.txt` type set to `Single` or `Multiplayer`.<br>Any custom value will mark the game as both SP and MP compatible, and type is set to whatever custom value. |
+| `url_dl`          | `url_update`       |      |
+| `url_info`        | `url_info`         |      |
+| `version`         | `version`          |      |
+
+

Documentation/mod-porting-guide.md

@@ -0,0 +1,110 @@
+# Self-made port
+## Compatibility with RISC architectures
+### Unaligned access
+Unaligned access on **i386** causes only performance penalty, but on **RISC** it can cause unstable work.
+
+For HLSDK at least you need such patches in util.cpp:
+ - https://github.com/FWGS/halflife/commit/7bfefe86e35d67867ae7af830ac1fc38f2908360
+ - https://github.com/FWGS/hlsdk-portable/commit/617d75545f2ecb9b2d46cc30728dc37c9eb6d35e
+
+### Signed chars
+`char` type defined as **signed** for **x86** and as **unsigned** for **arm**.
+
+And sometimes such difference can break logic.
+
+As a solution you can use `signed char` type in code directly or use `-fsigned-char` option for gcc/clang compilers.
+
+For HLSDK at least you need such [fix](https://github.com/FWGS/hlsdk-portable/commit/1ca34fcb4381682bd517612b530db22a1354a795) in nodes.cpp/.h.
+
+## Compatibility with 64bit architectures
+You need list of patches for Studio Model Render, MAKE_STRING macro and nodes:
+ - https://github.com/FWGS/hlsdk-portable/commit/d287ed446332e615ab5fb25ca81b99fa14d18a73
+ - https://github.com/FWGS/hlsdk-portable/commit/3bce17e3a04f8af10a927a07ceb8ab0f09152ec4
+ - https://github.com/FWGS/hlsdk-portable/commit/9ebfc981773ec4c7a89ffe52d9c249e1fbef9634
+ - https://github.com/FWGS/hlsdk-portable/commit/00833188dab87ef5746286479ba5aeb9d83b4a0c
+ - https://github.com/FWGS/hlsdk-portable/commit/4661b5c1a5245b27a5532745c11e44b5540e4172
+ - https://github.com/FWGS/hlsdk-portable/commit/2b61380146b1d58a8c465f0e312c061b12bda115
+ - https://github.com/FWGS/hlsdk-portable/commit/8ef6cb2427ee16a763103bd3f315f38e2f01cfe2
+
+## Mobility API
+Xash3D FWGS has special extended interface in `mobility_int.h` which adds some new features like vibration on mobile platforms.
+
+## Porting server-side code
+Original valve's server code was compatible with linux and gcc 2.x.
+
+Newer gcc versions have restriction which breaks build.
+
+Now, to make it building with gcc 4.x+ or clang, you need to do following:
+* Go to cbase.h and redefine macros as following
+```
+#define SetThink( a ) m_pfnThink = static_cast <void (CBaseEntity::*)(void)> (&a)
+#define SetTouch( a ) m_pfnTouch = static_cast <void (CBaseEntity::*)(CBaseEntity *)> (&a)
+#define SetUse( a ) m_pfnUse = static_cast <void (CBaseEntity::*)( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )> (&a)
+#define SetBlocked( a ) m_pfnBlocked = static_cast <void (CBaseEntity::*)(CBaseEntity *)> (&a)
+#define ResetThink( ) m_pfnThink = static_cast <void (CBaseEntity::*)(void)> (NULL)
+#define ResetTouch( ) m_pfnTouch = static_cast <void (CBaseEntity::*)(CBaseEntity *)> (NULL)
+#define ResetUse( ) m_pfnUse = static_cast <void (CBaseEntity::*)( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )> (NULL)
+#define ResetBlocked( ) m_pfnBlocked = static_cast <void (CBaseEntity::*)(CBaseEntity *)> (NULL)
+...
+#define SetMoveDone( a ) m_pfnCallWhenMoveDone = static_cast <void (CBaseToggle::*)(void)> (&a)
+```
+* Replace all SetThink(NULL), SetTouch(NULL), setUse(NULL) and SetBlocked(NULL) by ResetThink(), ResetTouch(), ResetUse() and ResetBlocked()
+* Sometimes you may need to add #include <ctype.h> if functions tolower or isspace are missing
+
+## Porting client-side code
+
+* Redefine all DLLEXPORT defines as empty field (Place it under _WIN32 macro if you want to keep windows compatibility).
+* Remove hud_servers.cpp and Servers_Init/Servers_Shutdown from hud.cpp.
+* Fix CAPS filenames in includes (like STDIO.H, replace by stdio.h).
+* Replace broken macros as DECLARE_MESSAGE, DECLARE_COMMAND by fixed examples from our hlsdk-portable port (cl_util.h).
+* Add ctype.h where is needed (tolower, isspace functions).
+* Add string.h where is needed (memcpy, strcpy, etc).
+* Use in_defs.h from hlsdk-portable.
+* Add input_xash3d.cpp from hlsdk-portable project to fix input.
+
+Now your client should be able to build and work correctly.
+
+# Porting mod to hlsdk-portable
+Look at changes which was made.
+
+If there are not too much changes (for example, only some weapons was added), add these changes in hlsdk-portable.
+
+You can use diff with original HLSDK and apply it as patch to hlsdk-portable.
+
+```
+NOTE: Many an old mods was made on HLSDK 2.0-2.1 and some rare mods on HLSDK 1.0.
+So you need to have different versions of HLSDK to make diffs.
+Plus different Spirit of Half-Life versions if mod was made on it.
+Also, weapons in old HLSDK versions does not use client weapon prediction system and you may be need to port standart half-life weapons to server side.
+```
+Files must have same line endings (use dos2unix on all files).
+
+We recommend to enable ignoring space changes in diff.
+
+Move all new files to separate directories.
+
+# Possible replacements for non-portable external dependencies
+1. If mod uses **fmod.dll** or **base.dll** to play mp3/ogg on client-side or to precache sounds on server-side, you can replace it with:
+	- [pfnPrimeMusicStream](https://github.com/FWGS/hlsdk-portable/blob/master/engine/cdll_int.h#L293=) engine callback;
+	- [miniaudio](https://github.com/mackron/miniaudio);
+	- [phonon](https://community.kde.org/Phonon).
+
+2. If mod uses **OpenGL**, porting code to Xash3D render interface is recommended.
+
+3. If mod uses **cg.dll**, you can try to port code to [NVFX](https://github.com/tlorach/nvFX).
+
+4. If mod uses detours, comment code or try to find replacement somehow by yourself.
+
+# Additional recommendations
+1. If mod uses STL, you can replace it with [MiniUTL](https://github.com/FWGS/MiniUTL).
+2. Avoid to use dynamic casts to make small size binaries.
+3. Avoid to use exceptions to make small size binaries.
+ 
+# Writing build scripts
+
+Use wscript/CMakeLists.txt files from hlsdk-portable as build scripts example.
+
+Get .c and .cpp file lists from Visual Studio project.
+
+Add missing include dirs.
+

Documentation/not-supported-mod-list-and-reasons-why.md

@@ -0,0 +1,11 @@
+# Not supported mods and reasons why
+
+|Name							|Version			|Why not working						|What was made for that
+|----							|-------			|---------------						|----------------------
+|Blue Shift						|The latest steam release	|Uses vgui2 library which xash3d does not support		|Recreated source code here: https://github.com/FWGS/hlsdk-xash3d/tree/bshift
+|Counter Strike						|1.6(The latest steam release)	|Uses vgui2 library which xash3d does not support		|Some work on vgui2 support was made here: https://github.com/FWGS/xash3d/tree/vinterface
+|Counter Strike: Condition Zero				|The latest steam release	|Uses vgui2 library which xash3d does not support		|Some work on vgui2 support was made here: https://github.com/FWGS/xash3d/tree/vinterface
+|Counter Strike: Condition Zero - Deleted scenes	|The latest steam release	|Uses vgui2 library which xash3d does not support		|Some work on vgui2 support was made here: https://github.com/FWGS/xash3d/tree/vinterface
+|Day of Defeat						|The latest steam release	|Uses vgui2 library which xash3d does not support		|Some work on vgui2 support was made here: https://github.com/FWGS/xash3d/tree/vinterface
+|Sven-Coop						|5.0+				|Uses custom GoldSrc engine					|
+

Documentation/opensource-mods.md

@@ -0,0 +1,378 @@
+Source code of this mods is available for modders and porters in public access.
+
+# Original Work
+## Absolute Zero
+Official gitlab repository - https://gitlab.com/Cobalt-57/half-life-absolute-zero/
+
+## Adrenaline Gamer
+Official github repository by Martin \"Bullet\" Webrant - https://github.com/martinwebrant/agmod
+
+## Arrangement
+Mirrored on github - https://github.com/JoelTroch/am_src_30jan2011
+
+## Arrangemode: Rebirth
+Mirrored on github - https://github.com/JoelTroch/am_src_rebirth
+
+## Battle Grounds
+Mirrored on github - https://github.com/nekonomicon/BattleGrounds
+
+## Bubblemod
+Download page on official site(WM snapshot) - [http://www.bubblemod.org/dl_default.php](https://web.archive.org/web/20130717133158/http://www.bubblemod.org/dl_default.php)
+
+Mirrored on github - https://github.com/HLSources/BubbleMod
+
+## Chicken Fortress
+Official github repository - https://github.com/CKFDevPowered/CKF3Alpha
+
+## Cold Ice
+Version 1.9 is available on ModDB - https://www.moddb.com/mods/cold-ice/downloads/cold-ice-sdk
+
+Version 1.9 mirrored on github - https://github.com/solidi/hl-mods/tree/master/ci
+
+## Cold Ice Ressurection
+Mirrored on github - https://github.com/solidi/hl-mods/tree/master/cir
+
+## Cthulhu
+Uploaded to github by Oleg Cherkasky - https://github.com/gunrunners-paradise/Cthulhu-HLmod-SDK
+
+## Deathmatch Classic
+Available in Valve's Half-Life repository - https://github.com/ValveSoftware/halflife/tree/master/dmc
+
+## ESHQ
+Official github repository - https://github.com/adslbarxatov/xash3d-for-ESHQ
+
+## Flat-Life
+Available on GamerLab - http://gamer-lab.com/eng/code_mods_goldsrc/Half-Life_2D_(Flat-Life)
+
+## Gang Wars
+Mirrored on github - https://github.com/nekonomicon/gw1.45src
+
+## Go-mod
+Versions 2.0 and 3.0, available in mod archives on ModDB - https://www.moddb.com/mods/go-mod/downloads
+
+Version 3.0, mirrored on github - https://github.com/nekonomicon/Go-mod30
+
+## GT mod
+Available on GamerLab - http://gamer-lab.com/eng/code_mods_goldsrc/GT_mod_(Polnie_ishodniki)
+
+## Half-Life: Advanced Deathmatch
+Mirrored on github - https://github.com/solidi/hl-mods/tree/master/hla
+
+## Half-Life: Decay
+Mirrored on github(PC Port) - https://github.com/hoaxer/Half-Life-Decay
+
+## Half-Life: Echoes
+Available on ModDB - https://www.moddb.com/mods/half-life-echoes
+
+## Half-Life: Expanded Arsenal
+Available on ModDB - https://www.moddb.com/mods/half-life-expanded-arsenal
+
+## Half-Life: Gravgun mod
+Branch **gravgun** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/gravgun
+
+## Half-Life: Invasion
+Official github repository - https://github.com/jlecorre/hlinvasion
+
+## Half-Life: Pong
+Mirrored on github - https://github.com/solidi/hl-mods/tree/master/pong
+
+## Half-Life: Quest Mode
+Available on cs-mapping.com.ua - https://old.cs-mapping.com.ua/forum/showthread.php?t=38030
+
+## Half-Life: Top-Down
+Official gitlab repository - https://gitlab.com/Sockman/hltopdown
+
+## Half-Life: Update
+Official github repository - https://github.com/Fograin/hl-subsmod-ex
+
+## Half-Life: Rally
+Official gitlab repository - https://gitlab.com/hlrally/src
+
+## Half-Life: Weapon Edition
+Available on ModDB - https://www.moddb.com/mods/half-life-weapon-edition/downloads/half-life-weapon-edition-1508-alpha-open-src
+
+## Half-Life: Year of the Dragon
+Available on ModDB - https://www.moddb.com/mods/year-of-the-dragon
+
+## Half-Nuked
+Available on ModDB - https://www.moddb.com/mods/half-nuked/downloads/half-nuked-src
+
+## Half-Payne
+Official github repository - https://github.com/suXinjke/HalfPayne
+
+## Half-Quake
+Official github repository - https://github.com/muddasheep/hqtrilogy
+
+## Half-Rats: Parasomnia
+Official github repository - https://github.com/HeathGames/half_rats_parasomnia_src
+
+## Half-Screwed
+Official github repository - https://github.com/desukuran/half-screwed
+
+## Headcrab Frenzy
+Version 1.3 on ModDB - https://www.moddb.com/mods/headcrab-frenzy/downloads/headcrab-frenzy-13-beta-source-code
+
+## Heart of Evil
+Mirrored on github - https://github.com/nekonomicon/HeartOfEvil
+
+## Ingram Chillin' Mod
+Official SourceForge repository - https://sourceforge.net/projects/icm-hl/
+
+## MechMod
+Official github repository - https://github.com/vermagav/mechmod
+
+## Mortal Combat Forever
+Available on GamerLab - http://gamer-lab.com/eng/code_mods_goldsrc/Mortal_Combat_Forever_(Polnie_ishodniki)
+
+## Natural Selection
+Official github repository - https://github.com/unknownworlds/NS
+
+## Overturn
+Available in mod archive on ModDB - https://www.moddb.com/mods/overturn
+
+## Oz Deathmatch
+Mirrored on github - https://github.com/nekonomicon/OZDM
+
+## Paranoia
+Available on ModDB - https://www.moddb.com/mods/paranoia/downloads/paranoia-toolkit
+
+## Paranoia 2: The Savior
+Prealpha, mirrored on github - https://github.com/a1batross/Paranoia2_ancient
+
+Version 1.51, mirrored on github - https://github.com/a1batross/Paranoia2_original
+
+## Raven City
+*Unfinished mod*
+
+Was found on HLFX - http://hlfx.ru/forum/showthread.php?s=2c892dfc52f72be52a89c3f52a397cd0&threadid=1819&postid=44674#post44674
+
+## Ricochet
+Available in Valve's Half-Life repository - https://github.com/ValveSoftware/halflife/tree/master/ricochet
+
+## Spirit of Half-Life
+[Logic&Trick's](https://github.com/LogicAndTrick) mirror - https://files.logic-and-trick.com/#/Half-Life/Mods/Spirit%20of%20Half-Life
+
+## The Wastes
+Version 1.5: mirrored on code.idtech.space - https://code.idtech.space/vera/halflife-thewastes-sdk
+
+## Threewave CTF
+*Unfinished mod by Valve Software*
+
+Available in Valve's Half-Life repository with Deathmatch Classic sources - https://github.com/ValveSoftware/halflife/tree/master/dmc
+
+## Trinity Render
+Available on ModDB - https://www.moddb.com/mods/half-life-episode-two/downloads/trinity-rendering-engine-v308f
+
+## Tyrian: Ground Assault
+Available on ModDB - https://www.moddb.com/mods/tyriangroundassault/downloads/tyrianga-v1-0-src
+
+## Wasteland
+Mirrored on code.idtech.space - https://code.idtech.space/vera/halflife-wasteland-sdk
+
+## Wizard Wars
+Download page on official site - http://www.thothie.com/ww/
+
+## XashXT
+Mirrored on github - https://github.com/a1batross/XashXT_original
+
+## Xen-Warrior
+*Source code is a part of Spirit of Half-Life 1.0-1.2 under XENWARRIOR macro*
+
+[Logic&Trick's](https://github.com/LogicAndTrick) mirror - https://files.logic-and-trick.com/#/Half-Life/Mods/Spirit%20of%20Half-Life
+
+## Zombie-X
+Available in mod archive on ModDB - https://www.moddb.com/mods/zombie-x-10-final/downloads/zombie-x-10-dle-beta6-last-version
+
+## ZXC
+Available on ModDB - https://www.moddb.com/mods/zxc-mod-133/downloads/zxc-mod-136-final
+
+Mirrored on github - https://github.com/ZXCmod/ZXCmod
+
+# Reimplementation
+## Absolute Redemption
+Branch **redempt** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/redempt
+
+## Adrenaline Gamer
+OpenAG by YaLTeR - https://github.com/YaLTeR/OpenAG
+
+## Afraid of Monsters
+malortie's recreation - https://github.com/malortie/hl-aom
+
+Branch **aom** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/aom
+
+## Afraid of Monsters: Director's cut
+Reverse-engineered code: branch **aomdc** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/aomdc
+
+## Azure Sheep
+malortie's recreation - https://github.com/malortie/hl-asheep
+
+Reverse-engineered code: branch **asheep** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/asheep
+
+## Big Lolly
+malortie's recreation - https://github.com/malortie/hl-biglolly
+
+Branch **biglolly** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/biglolly
+
+## Black Ops
+malortie's recreation - https://github.com/malortie/hl-blackops
+
+Branch **blackops** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/blackops
+
+## Bloody Pizza: Vendetta
+Branch **caseclosed** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/caseclosed
+
+## Case Closed
+Branch **caseclosed** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/caseclosed
+
+## Cleaner's Adventures
+Branch **CAd** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/CAd
+
+## Counter Strike
+Reverse-engineered code of client part by a1batross - https://github.com/Velaron/cs16-client
+
+Reverse-engineered code of server part by nagist - https://github.com/nagist/cs16nd
+
+Reverse-engineered code of server part by s1lentq - https://github.com/s1lentq/ReGameDLL_CS
+
+## Counter Strike Online
+CSO-like Xash3D-based mod, CSMoE - https://github.com/MoeMod/CSMoE
+
+## Crack-Life: Campaign Mode
+Recreation by lostgamer aka nillerusr - https://github.com/LostGamerHL/crack_life
+
+## Escape from the Darkness
+malortie's recreation - https://github.com/malortie/hl-eftd
+
+Reverse-engineered code: branch **eftd** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/eftd
+
+## Half-Life: Black Guard
+*This mod uses dlls from Cleaner's Adventures*
+
+Branch **CAd** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/CAd
+
+## Half-Life: Blue Shift
+Unkle Mike's recreation - https://hlfx.ru/forum/showthread.php?s=&threadid=5253
+
+Reverse-engineered code: branch **bshift** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/bshift
+
+## Half-Life: Induction
+Branch **induction** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/induction
+
+## Half-Life: Opposing Force
+Recreation by lostgamer aka nillerusr - https://github.com/LostGamerHL/hlsdk-xash3d
+
+Reverse-engineered code: clean branch **opfor** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/opfor
+
+Spirit of Half Life: Opposing-Force Edition - https://github.com/Hammermaps-DEV/SOHL-V1.9-Opposing-Force-Edition
+
+## Half-Life: Rebellion
+Reverse-engineered code: branch **rebellion** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/rebellion
+
+## Half-Life: Urbicide
+Branch **hl_urbicide** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/hl_urbicide
+
+## Half-Life: Visitors
+malortie's recreation - https://github.com/malortie/hl-visitors
+
+Reverse-engineered code: branch **visitors** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/visitors
+
+## Half-Secret
+Branch **half-secret** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/half-secret
+
+## Night at the Office
+malortie's recreation - https://github.com/malortie/hl-nato
+
+Branch **noffice** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/noffice
+
+## Poke 646
+malortie's recreation - https://github.com/malortie/hl-poke646
+
+Reverse-engineered code: branch **poke646** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/poke646
+
+## Poke 646: Vendetta
+malortie's recreation - https://github.com/malortie/hl-poke646-vendetta
+
+Reverse-engineered code: branch **poke646_vendetta** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/poke646_vendetta
+
+## Residual Life
+Reverse-engineered code: branch **residual_point** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/residual_point
+
+## Residual Point
+Reverse-engineered code: branch **residual_point** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/residual_point
+
+## Sewer Beta
+Branch **sewer_beta** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/sewer_beta
+
+## Team Fortress Classic
+Reverse-engineered code by Velaron - https://github.com/Velaron/tf15-client
+
+## The Gate
+malortie's recreation - https://github.com/malortie/hl-thegate
+
+Reverse-engineered code: branch **thegate** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/thegate
+
+## They Hunger
+malortie's recreation - https://github.com/malortie/hl-theyhunger
+
+Reverse-engineered code: branch **theyhunger** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/theyhunger
+
+They Hunger: Tactical - https://www.moddb.com/mods/they-hunger-tactical/downloads/tht-source-code-documentation
+
+## Times of Troubles
+malortie's recreation - https://github.com/malortie/hl-tot
+
+Branch **tot** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/tot
+
+# Derived work
+## Adrenaline Gamer
+Branch **aghl** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/aghl
+
+## Bubblemod
+Branch **bubblemod** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/bubblemod
+
+## Deathmatch Classic
+Deathmatch Classic: Adrenaline Gamer Edition - https://github.com/martinwebrant/agmod/tree/master/src/dmc
+
+Deathmatch Quaked - https://www.moddb.com/games/deathmatch-classic/downloads/dmq2
+
+Branch **dmc** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/dmc
+
+## Half-Life: Echoes
+Branch **echoes** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/echoes
+
+## Half-Life: Invasion
+Port to HLSDK 2.4 by malortie - https://github.com/malortie/hl-invasion
+
+Port to Linux by fmoraw - https://github.com/fmoraw/hlinvasion
+
+Branch **invasion** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/invasion
+
+## Half-Life: Top-Down
+Branch **hltopdown** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/hltopdown
+
+## Half-Screwed
+Branch **half-screwed** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/half-screwed
+
+## Natural Selection
+Port to Linux - https://github.com/fmoraw/NS
+
+## Spirit of Half-Life
+Version 1.2: branch **sohl1.2** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/sohl1.2
+
+## Swiss Cheese Halloween 2002
+Just more playable version by malortie - https://github.com/malortie/hl-shall
+
+Branch **halloween** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/halloween
+
+## The Wastes
+Version 1.5: Port to Linux - https://git.mentality.rip/a1batross/halflife-thewastes-sdk
+
+## Threewave CTF
+Branch **dmc** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/dmc
+
+## Xen-Warrior
+Branch **sohl1.2** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/sohl1.2
+
+## Zombie-X
+Branch **zombie-x** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/zombie-x
+

Documentation/ports.md

@@ -0,0 +1,33 @@
+Xash3D FWGS is intended to be easily ported to specific platform, however main issue is maintaining such ports. 
+
+This page is about merged ports to main source tree and responsible for it developers.
+
+For porting guidelines, look engine-porting-guide.md.
+
+Status: 
+* **Supported**: active, was confirmed to be fully functional.
+* **In progress**: active, under development.
+* **Old Engine**: port was for old engine fork
+* **Not maintained**: lack of human resources
+* **Deprecated**: not supported anymore
+
+Table is sorted by status and platform.
+
+| Platform        | Status                     | Maintainer               | Note
+| --------        | ------                     | ----------               | ----
+| Android         | Supported                  | @Velaron                 |
+| *BSD            | Supported                  | @nekonomicon             |
+| DOS4GW          | Supported                  | @mittorn                 |
+| GNU/Linux       | Supported                  | @a1batross, @mittorn     |
+| Haiku           | Supported                  | not maintained           | Was added by #478 and #483
+| macOS           | Supported                  | @sofakng                 | 
+| MotoMAGX        | Supported                  | @a1batross               |
+| PSVita          | Supported                  | @fgsfdsfgs               |
+| Switch          | Supported                  | @fgsfdsfgs               |
+| Windows         | Supported                  | @a1batross, @SNMetamorph |
+| PSP             | In progress                | @Crow_bar, @Velaron      | [GitHub Repository](https://github.com/Crow-bar/xash3d-fwgs)
+| Wii             | In progress                | Collaborative effort     | [GitHub Repository](https://github.com/saucesaft/xash3d-wii)
+| Emscripten      | Old Engine                 | not maintained           | 
+| 3DS             | Old Engine fork            | not maintained           | [GitHub Repository](https://github.com/masterfeizz/Xash3DS)
+| Oculus Quest    | Old Engine fork            | @DrBeef                  | [GitHub Repository](https://github.com/DrBeef/Lambda1VR)
+| iOS             | Deprecated                 | not maintained           | See GitHub issue #61

Documentation/psvita.md

@@ -0,0 +1,49 @@
+## PlayStation Vita port
+
+### Prerequisites
+1. Make sure your PSVita is [set up to run homebrew applications](https://vita.hacks.guide/).
+2. Install [kubridge](https://github.com/TheOfficialFloW/kubridge/releases/) by copying `kubridge.suprx` to your taiHEN plugins folder (usually `ux0:/tai`) and add it to your `config.txt`, for example:
+   ```
+   *KERNEL
+   ux0:tai/kubridge.skprx
+   ```
+3. Install `libshacccg.suprx` by following [this guide](https://cimmerian.gitbook.io/vita-troubleshooting-guide/shader-compiler/extract-libshacccg.suprx).
+
+### Installation
+1. If you have an old vitaXash3D install, remove it.
+2. Get `xash3d-fwgs-psvita.7z` from the latest [automatic build](https://github.com/FWGS/xash3d-fwgs/releases/tag/continuous).
+3. Install `xash.vpk` from the 7z archive onto your PSVita.
+4. Copy the `data` directory from the 7z archive to the root of your PSVita's SD card.
+5. Copy the valve folder and any other mod folders from your Half-Life install to `ux0:/data/xash3d/` (you can use other mountpoints instead of `ux0`). **Do not overwrite anything.**
+
+### Build instructions
+1. Install [VitaSDK](https://vitasdk.org/).
+2. Build and install [vitaGL](https://github.com/Rinnegatamante/vitaGL):
+    ```
+    git clone https://github.com/Rinnegatamante/vitaGL.git
+    make -C vitaGL NO_TEX_COMBINER=1 HAVE_UNFLIPPED_FBOS=1 HAVE_PTHREAD=1 SINGLE_THREADED_GC=1 MATH_SPEEDHACK=1 DRAW_SPEEDHACK=1 HAVE_CUSTOM_HEAP=1 -j2 install
+    ```
+3. Build and install [vita-rtld](https://github.com/fgsfdsfgs/vita-rtld):
+    ```
+    git clone https://github.com/fgsfdsfgs/vita-rtld.git && cd vita-rtld
+    mkdir build && cd build
+    cmake -DCMAKE_BUILD_TYPE=Release ..
+    make -j2 install
+    ```
+4. Build and install [this SDL2 fork](https://github.com/Northfear/SDL) with vitaGL integration:
+    ```
+    git clone https://github.com/Northfear/SDL.git && cd SDL
+    mkdir build && cd build
+    cmake -DCMAKE_TOOLCHAIN_FILE=${VITASDK}/share/vita.toolchain.cmake -DCMAKE_BUILD_TYPE=Release -DVIDEO_VITA_VGL=ON ..
+    make -j2 install
+    ```
+5. Use `waf`:
+    ```
+    ./waf configure -T release --psvita
+    ./waf build
+    ```
+6. Copy all the resulting `.so` files into a single folder:
+    ```
+    ./waf install --destdir=xash3d
+    ```
+7. `xash.vpk` is located in `build/engine/`.

Documentation/public-servers-rules-and-recommendations.md

@@ -0,0 +1,15 @@
+As online community is growing, we don't want to keep bad or invalid servers on the Internet Games list. It's a common rules for all Xash3D server owners who are using default master server. 
+
+1. Breaking master server or clients is prohibited in any way. If you found a serious bug, contact us at contact 'at' fwgs.ru or post an issue at GitHub.
+
+2. Changing settings, exploiting vulnerabilities of clients is prohibited in any way. If you found a serious bug, contact us at contact 'at' fwgs.ru or post an issue at GitHub.
+
+2. Agressive advertisement and spam on other servers is prohibited in any way.
+
+3. If your server is require downloading custom content, it should be available for everyone. Recommended way to deliver custom content is FastDL.
+
+4. It's recommended to keep your server is up-to-date. You may use our public Debian/Ubuntu/Arch Linux [repository](https://github.com/FWGS/xash3d/wiki/How-to-set-up-a-Xash3D-Dedicated-Server-on-Debian-or-Ubuntu) to simplify updating process.
+
+Just follow these rules to not get banned on our master server. Good luck, have fun!
+
+

README.md

@@ -0,0 +1,92 @@
+# Xash3D FWGS Engine <img align="right" width="128" height="128" src="https://github.com/FWGS/xash3d-fwgs/raw/master/game_launch/icon-xash-material.png" alt="Xash3D FWGS icon" />
+[![GitHub Actions Status](https://github.com/FWGS/xash3d-fwgs/actions/workflows/c-cpp.yml/badge.svg)](https://github.com/FWGS/xash3d-fwgs/actions/workflows/c-cpp.yml) [![FreeBSD Build Status](https://img.shields.io/cirrus/github/FWGS/xash3d-fwgs?label=freebsd%20build)](https://cirrus-ci.com/github/FWGS/xash3d-fwgs) [![Discord Server](https://img.shields.io/discord/355697768582610945.svg)](http://fwgsdiscord.mentality.rip/) \
+[![Download Stable](https://img.shields.io/badge/download-stable-yellow)](https://github.com/FWGS/xash3d-fwgs/releases/latest) [![Download Testing](https://img.shields.io/badge/downloads-testing-orange)](https://github.com/FWGS/xash3d-fwgs/releases/tag/continuous)
+
+Xash3D FWGS is a game engine, aimed to provide compatibility with Half-Life Engine and extend it, as well as to give game developers well known workflow.
+
+Xash3D FWGS is a heavily modified fork of an original [Xash3D Engine](https://www.moddb.com/engines/xash3d-engine) by Unkle Mike.
+
+## Donate
+[![Donate to FWGS button](https://img.shields.io/badge/Donate_to_FWGS-%3C3-magenta)](Documentation/donate.md) \
+If you like Xash3D FWGS, consider supporting individual engine maintainers. By supporting us, you help to continue developing this game engine further. The sponsorship links are available in [documentation](Documentation/donate.md).
+
+## Fork features
+* Steam Half-Life (HLSDK 2.4) support.
+* Crossplatform and modern compilers support: supports Windows, Linux, BSD & Android on x86 & ARM and [many more](Documentation/ports.md).
+* Better multiplayer support: multiple master servers, headless dedicated server, voice chat and IPv6 support.
+* Multiple renderers support: OpenGL, GLESv1, GLESv2 and Software.
+* Advanced virtual filesystem: `.pk3` and `.pk3dir` support, compatibility with GoldSrc FS module, fast case-insensitivity emulation for crossplatform.
+* Mobility API: better game integration on mobile devices (vibration, touch controls)
+* Different input methods: touch and gamepad in addition to mouse & keyboard.
+* TrueType font rendering, as a part of mainui_cpp.
+* External VGUI support module.
+* PNG & KTX2 image format support.
+* [A set of small improvements](Documentation/), without broken compatibility.
+
+## Installation & Running
+0) Get Xash3D FWGS binaries: you can use [testing](https://github.com/FWGS/xash3d-fwgs/releases/tag/continuous) build or you can compile engine from source code.
+1) Copy engine binaries to some directory.
+2) Copy `valve` directory from [Half-Life](https://store.steampowered.com/app/70/HalfLife/) to directory with engine binaries.
+If your CPU is NOT x86 compatible or you're running 64-bit version of the engine, you may want to compile [Half-Life SDK](https://github.com/FWGS/hlsdk-portable).
+This repository contains our fork of HLSDK and restored source code for some of the mods. Not all of them, of course.
+You still needed to copy `valve` directory as all game resources located there.
+3) Run the main executable (`xash3d.exe` or AppImage).
+
+For additional info, run Xash3D with `-help` command line key.
+
+## Contributing
+* Before sending an issue, check if someone already reported your issue. Make sure you're following "How To Ask Questions The Smart Way" guide by Eric Steven Raymond. Read more: http://www.catb.org/~esr/faqs/smart-questions.html
+* Issues are accepted in both English and Russian
+* Before sending a PR, check if you followed our contribution guide in CONTRIBUTING.md file.
+
+## Build instructions
+We are using Waf build system. If you have some Waf-related questions, I recommend you to read https://waf.io/book/
+
+NOTE: NEVER USE GitHub's ZIP ARCHIVES. GitHub doesn't include external dependencies we're using!
+
+### Prerequisites
+
+If your CPU is x86 compatible, we are building 32-bit code by default. This was done to maintain compatibility with Steam releases of Half-Life and based on it's engine games.
+Even if Xash3D FWGS does support targetting 64-bit, you can't load games without recompiling them from source code!
+
+If your CPU is NOT x86 compatible or you decided build 64-bit version of engine, you may want to compile [Half-Life SDK](https://github.com/FWGS/hlsdk-portable).
+This repository contains our fork of HLSDK and restored source code for some of the mods. Not all of them, of course.
+
+#### Windows (Visual Studio)
+* Install Visual Studio.
+* Install latest [Python](https://python.org) **OR** run `cinst python.install` if you have Chocolatey.
+* Install latest [Git](https://git-scm.com/download/win) **OR** run `cinst git.install` if you have Chocolatey.
+* Download [SDL2](https://libsdl.org/download-2.0.php) development package for Visual Studio.
+* Clone this repository: `git clone --recursive https://github.com/FWGS/xash3d-fwgs`.
+* Make sure you have at least 12GB of free space to store all build-time dependencies: ~10GB for Visual Studio, 300 MB for Git, 100 MB for Python and other.
+
+#### GNU/Linux
+##### Debian/Ubuntu
+* Enable i386 on your system, if you're compiling 32-bit engine on amd64. If not, skip this
+
+`$ sudo dpkg --add-architecture i386`
+* Install development tools
+  * For 32-bit engine on amd64: \
+    `$ sudo apt install build-essential gcc-multilib g++-multilib python libsdl2-dev:i386 libfontconfig-dev:i386 libfreetype6-dev:i386`
+  * For everything else: \
+    `$ sudo apt install build-essential python libsdl2-dev libfontconfig-dev libfreetype6-dev`
+* Clone this repostory:
+`$ git clone --recursive https://github.com/FWGS/xash3d-fwgs`
+
+### Building
+#### Windows (Visual Studio)
+0) Open command line
+1) Navigate to `xash3d-fwgs` directory.
+2) Carefully examine which build options are available: `waf --help`
+3) Configure build: `waf configure -T release --sdl2=c:/path/to/SDL2`
+4) Compile: `waf build`
+5) Install: `waf install --destdir=c:/path/to/any/output/directory`
+
+#### Linux
+If compiling 32-bit on amd64, you may need to supply `export PKG_CONFIG_PATH=/usr/lib/i386-linux-gnu/pkgconfig` prior to running configure.
+
+0) Examine which build options are available: `./waf --help`
+1) Configure build: `./waf configure -T release`
+(You need to pass `-8` to compile 64-bit engine on 64-bit x86 processor)
+2) Compile: `./waf build`
+3) Install(optional): `./waf install --destdir=/path/to/any/output/directory`

common/backends.h

@@ -0,0 +1,53 @@
+/*
+backends.h - backend macro definitions
+Copyright (C) 2016 Mittorn
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+*/
+#ifndef BACKENDS_H
+#define BACKENDS_H
+
+// video backends (XASH_VIDEO)
+#define VIDEO_NULL    0
+#define VIDEO_SDL     1
+#define VIDEO_FBDEV   3
+#define VIDEO_DOS     4
+
+// audio backends (XASH_SOUND)
+#define SOUND_NULL     0
+#define SOUND_SDL      1
+#define SOUND_ALSA     3
+
+// input (XASH_INPUT)
+#define INPUT_NULL    0
+#define INPUT_SDL     1
+#define INPUT_EVDEV   3
+
+// timer (XASH_TIMER)
+#define TIMER_NULL  0 // not used
+#define TIMER_SDL   1
+#define TIMER_POSIX 2
+#define TIMER_WIN32 3
+#define TIMER_DOS   4
+
+// messageboxes (XASH_MESSAGEBOX)
+#define MSGBOX_STDERR  0
+#define MSGBOX_SDL     1
+#define MSGBOX_WIN32   3
+#define MSGBOX_NSWITCH 4
+
+// library loading (XASH_LIB)
+#define LIB_NULL 0
+#define LIB_POSIX 1
+#define LIB_WIN32 2
+#define LIB_STATIC 3
+
+#endif /* BACKENDS_H */

common/bspfile.h

@@ -61,23 +61,27 @@ BRUSH MODELS
 #define LS_UNUSED			0xFE
 #define LS_NONE			0xFF
 
+#define MAX_MAP_CLIPNODES_HLBSP 32767
+#define MAX_MAP_CLIPNODES_BSP2  524288
+
 // these limis not using by modelloader but only for displaying 'mapstats' correctly
 #ifdef SUPPORT_BSP2_FORMAT
 #define MAX_MAP_MODELS		2048		// embedded models
 #define MAX_MAP_ENTSTRING		0x200000		// 2 Mb should be enough
 #define MAX_MAP_PLANES		131072		// can be increased without problems
 #define MAX_MAP_NODES		262144		// can be increased without problems
-#define MAX_MAP_CLIPNODES		524288		// can be increased without problems
+#define MAX_MAP_CLIPNODES		MAX_MAP_CLIPNODES_BSP2		// can be increased without problems
 #define MAX_MAP_LEAFS		131072		// CRITICAL STUFF to run ad_sepulcher!!!
 #define MAX_MAP_VERTS		524288		// can be increased without problems
 #define MAX_MAP_FACES		262144		// can be increased without problems
 #define MAX_MAP_MARKSURFACES		524288		// can be increased without problems
 #else
-#define MAX_MAP_MODELS		768		// embedded models
+// increased to match PrimeXT compilers
+#define MAX_MAP_MODELS		1024		// embedded models
 #define MAX_MAP_ENTSTRING		0x100000		// 1 Mb should be enough
 #define MAX_MAP_PLANES		65536		// can be increased without problems
 #define MAX_MAP_NODES		32767		// because negative shorts are leafs
-#define MAX_MAP_CLIPNODES		32767		// because negative shorts are contents
+#define MAX_MAP_CLIPNODES		MAX_MAP_CLIPNODES_HLBSP		// because negative shorts are contents
 #define MAX_MAP_LEAFS		32767		// signed short limit
 #define MAX_MAP_VERTS		65535		// unsigned short limit
 #define MAX_MAP_FACES		65535		// unsigned short limit

common/com_image.h

@@ -0,0 +1,134 @@
+#pragma once
+/*
+========================================================================
+
+internal image format
+
+typically expanded to rgba buffer
+NOTE: number at end of pixelformat name it's a total bitscount e.g. PF_RGB_24 == PF_RGB_888
+========================================================================
+*/
+#define ImageRAW( type )	(type == PF_RGBA_32 || type == PF_BGRA_32 || type == PF_RGB_24 || type == PF_BGR_24 || type == PF_LUMINANCE)
+#define ImageCompressed( type ) \
+	(  type == PF_DXT1 \
+	|| type == PF_DXT3 \
+	|| type == PF_DXT5 \
+	|| type == PF_ATI2 \
+	|| type == PF_BC4_SIGNED \
+	|| type == PF_BC4_UNSIGNED \
+	|| type == PF_BC5_SIGNED \
+	|| type == PF_BC5_UNSIGNED \
+	|| type == PF_BC6H_SIGNED \
+	|| type == PF_BC6H_UNSIGNED \
+	|| type == PF_BC7_UNORM \
+	|| type == PF_BC7_SRGB \
+	|| type == PF_KTX2_RAW )
+
+typedef enum
+{
+	PF_UNKNOWN = 0,
+	PF_INDEXED_24,	// inflated palette (768 bytes)
+	PF_INDEXED_32,	// deflated palette (1024 bytes)
+	PF_RGBA_32,	// normal rgba buffer
+	PF_BGRA_32,	// big endian RGBA (MacOS)
+	PF_RGB_24,	// uncompressed dds or another 24-bit image
+	PF_BGR_24,	// big-endian RGB (MacOS)
+	PF_LUMINANCE,
+	PF_DXT1,		// s3tc DXT1/BC1 format
+	PF_DXT3,		// s3tc DXT3/BC2 format
+	PF_DXT5,		// s3tc DXT5/BC3 format
+	PF_ATI2,		// latc ATI2N/BC5 format
+	PF_BC4_SIGNED,
+	PF_BC4_UNSIGNED,
+	PF_BC5_SIGNED,
+	PF_BC5_UNSIGNED,
+	PF_BC6H_SIGNED,	// bptc BC6H signed FP16 format
+	PF_BC6H_UNSIGNED, // bptc BC6H unsigned FP16 format
+	PF_BC7_UNORM,			// bptc BC7 format
+	PF_BC7_SRGB,
+	PF_KTX2_RAW, // Raw KTX2 data, used for yet unsupported KTX2 subformats
+	PF_TOTALCOUNT,	// must be last
+} pixformat_t;
+
+typedef struct bpc_desc_s
+{
+	int	format;	// pixelformat
+	char	name[16];	// used for debug
+	uint	glFormat;	// RGBA format
+	int	bpp;	// channels (e.g. rgb = 3, rgba = 4)
+} bpc_desc_t;
+
+// imagelib global settings
+typedef enum
+{
+	IL_USE_LERPING	= BIT(0),	// lerping images during resample
+	IL_KEEP_8BIT	= BIT(1),	// don't expand paletted images
+	IL_ALLOW_OVERWRITE	= BIT(2),	// allow to overwrite stored images
+	IL_DONTFLIP_TGA	= BIT(3),	// Steam background completely ignore tga attribute 0x20 (stupid lammers!)
+	IL_DDS_HARDWARE	= BIT(4),	// DXT compression is support
+	IL_LOAD_DECAL	= BIT(5),	// special mode for load gradient decals
+	IL_OVERVIEW	= BIT(6),	// overview required some unque operations
+	IL_LOAD_PLAYER_DECAL = BIT(7), // special mode for player decals
+	IL_KTX2_RAW = BIT(8), // renderer can consume raw KTX2 files (e.g. ref_vk)
+} ilFlags_t;
+
+// goes into rgbdata_t->encode
+#define DXT_ENCODE_DEFAULT		0	// don't use custom encoders
+#define DXT_ENCODE_COLOR_YCoCg	0x1A01	// make sure that value dosn't collide with anything
+#define DXT_ENCODE_ALPHA_1BIT		0x1A02	// normal 1-bit alpha
+#define DXT_ENCODE_ALPHA_8BIT		0x1A03	// normal 8-bit alpha
+#define DXT_ENCODE_ALPHA_SDF		0x1A04	// signed distance field
+#define DXT_ENCODE_NORMAL_AG_ORTHO	0x1A05	// orthographic projection
+#define DXT_ENCODE_NORMAL_AG_STEREO	0x1A06	// stereographic projection
+#define DXT_ENCODE_NORMAL_AG_PARABOLOID	0x1A07	// paraboloid projection
+#define DXT_ENCODE_NORMAL_AG_QUARTIC	0x1A08	// newton method
+#define DXT_ENCODE_NORMAL_AG_AZIMUTHAL	0x1A09	// Lambert Azimuthal Equal-Area
+
+// rgbdata output flags
+typedef enum
+{
+	// rgbdata->flags
+	IMAGE_CUBEMAP	= BIT(0),		// it's 6-sides cubemap buffer
+	IMAGE_HAS_ALPHA	= BIT(1),		// image contain alpha-channel
+	IMAGE_HAS_COLOR	= BIT(2),		// image contain RGB-channel
+	IMAGE_COLORINDEX	= BIT(3),		// all colors in palette is gradients of last color (decals)
+	IMAGE_HAS_LUMA	= BIT(4),		// image has luma pixels (q1-style maps)
+	IMAGE_SKYBOX	= BIT(5),		// only used by FS_SaveImage - for write right suffixes
+	IMAGE_QUAKESKY	= BIT(6),		// it's a quake sky double layered clouds (so keep it as 8 bit)
+	IMAGE_DDS_FORMAT	= BIT(7),		// a hint for GL loader
+	IMAGE_MULTILAYER	= BIT(8),		// to differentiate from 3D texture
+	IMAGE_ONEBIT_ALPHA	= BIT(9),		// binary alpha
+	IMAGE_QUAKEPAL	= BIT(10),	// image has quake1 palette
+
+	// Image_Process manipulation flags
+	IMAGE_FLIP_X	= BIT(16),	// flip the image by width
+	IMAGE_FLIP_Y	= BIT(17),	// flip the image by height
+	IMAGE_ROT_90	= BIT(18),	// flip from upper left corner to down right corner
+	IMAGE_ROT180	= IMAGE_FLIP_X|IMAGE_FLIP_Y,
+	IMAGE_ROT270	= IMAGE_FLIP_X|IMAGE_FLIP_Y|IMAGE_ROT_90,
+// reserved
+	IMAGE_RESAMPLE	= BIT(20),	// resample image to specified dims
+// reserved
+// reserved
+	IMAGE_FORCE_RGBA	= BIT(23),	// force image to RGBA buffer
+	IMAGE_MAKE_LUMA	= BIT(24),	// create luma texture from indexed
+	IMAGE_QUANTIZE	= BIT(25),	// make indexed image from 24 or 32- bit image
+	IMAGE_LIGHTGAMMA	= BIT(26),	// apply gamma for image
+	IMAGE_REMAP	= BIT(27),	// interpret width and height as top and bottom color
+} imgFlags_t;
+
+typedef struct rgbdata_s
+{
+	word	width;		// image width
+	word	height;		// image height
+	word	depth;		// image depth
+	uint	type;		// compression type
+	uint	flags;		// misc image flags
+	word	encode;		// DXT may have custom encoder, that will be decoded in GLSL-side
+	byte	numMips;		// mipmap count
+	byte	*palette;		// palette if present
+	byte	*buffer;		// image buffer
+	rgba_t	fogParams;	// some water textures in hl1 has info about fog color and alpha
+	size_t	size;		// for bounds checking
+} rgbdata_t;
+

common/com_model.h

@@ -16,11 +16,9 @@ GNU General Public License for more details.
 #ifndef COM_MODEL_H
 #define COM_MODEL_H
 
+#include "xash3d_types.h"
 #include "bspfile.h"	// we need some declarations from it
 
-typedef vec_t		vec2_t[2];
-typedef vec_t		vec4_t[4];
-
 /*
 ==============================================================================
 
@@ -34,7 +32,8 @@ typedef vec_t		vec4_t[4];
 
 #define MIPLEVELS		4
 #define VERTEXSIZE		7
-#define MAXLIGHTMAPS	4
+#define MAXLIGHTMAPS	4	// max light styles per face
+#define MAXDYNLIGHTS	8	// maximum dynamic lights per one pixel
 #define NUM_AMBIENTS	4		// automatic ambient sounds
 
 // model types
@@ -106,7 +105,7 @@ typedef struct
 
 	vec3_t		mins, maxs;	// terrain bounds (fill by user)
 
-	int		reserved[32];	// just for future expansions or mod-makers
+	intptr_t	reserved[32];	// just for future expansions or mod-makers
 } mfaceinfo_t;
 
 typedef struct
@@ -175,7 +174,7 @@ struct decal_s
 // Xash3D specific
 	vec3_t		position;		// location of the decal center in world space.
 	glpoly_t	*polys;		// precomputed decal vertices
-	int		reserved[4];	// just for future expansions or mod-makers
+	intptr_t	reserved[4];	// just for future expansions or mod-makers
 };
 
 typedef struct mleaf_s
@@ -229,10 +228,10 @@ typedef struct mextrasurf_s
 	unsigned short	numverts;		// world->vertexes[]
 	int		firstvertex;	// fisrt look up in tr.tbn_vectors[], then acess to world->vertexes[]
 
-	int		reserved[32];	// just for future expansions or mod-makers
+	intptr_t	reserved[32];	// just for future expansions or mod-makers
 } mextrasurf_t;
 
-typedef struct msurface_s
+struct msurface_s
 {
 	int		visframe;		// should be drawn when node is crossed
 
@@ -264,7 +263,7 @@ typedef struct msurface_s
 
 	color24		*samples;		// note: this is the actual lightmap data for this surface
 	decal_t		*pdecals;
-} msurface_t;
+};
 
 typedef struct hull_s
 {
@@ -292,7 +291,7 @@ typedef struct model_s
 	// shared modelinfo
 	modtype_t		type;		// model type
 	int		numframes;	// sprite's framecount
-	byte		*mempool;		// private mempool (was synctype)
+	poolhandle_t mempool;		// private mempool (was synctype)
 	int		flags;		// hl compatibility
 
 //
@@ -504,4 +503,36 @@ typedef struct
 	maliasframedesc_t	frames[1];	// variable sized
 } aliashdr_t;
 
+
+
+// remapping info
+#define SUIT_HUE_START		192
+#define SUIT_HUE_END		223
+#define PLATE_HUE_START		160
+#define PLATE_HUE_END		191
+
+#define SHIRT_HUE_START		16
+#define SHIRT_HUE_END		32
+#define PANTS_HUE_START		96
+#define PANTS_HUE_END		112
+
+
+// 1/32 epsilon to keep floating point happy
+#define DIST_EPSILON		(1.0f / 32.0f)
+#define FRAC_EPSILON		(1.0f / 1024.0f)
+#define BACKFACE_EPSILON		0.01f
+#define MAX_BOX_LEAFS		256
+#define ANIM_CYCLE			2
+#define MOD_FRAMES			20
+
+
+
+#define MAX_DEMOS		32
+#define MAX_MOVIES		8
+#define MAX_CDTRACKS	32
+#define MAX_CLIENT_SPRITES	512	// SpriteTextures (0-256 hud, 256-512 client)
+#define MAX_EFRAGS		8192	// Arcane Dimensions required
+#define MAX_REQUESTS	64
+
+
 #endif//COM_MODEL_H

common/const.h

@@ -20,45 +20,45 @@
 // Most came from server.h
 
 // edict->flags
-#define FL_FLY		(1<<0)	// Changes the SV_Movestep() behavior to not need to be on ground
+#define FL_FLY		(1U<<0)	// Changes the SV_Movestep() behavior to not need to be on ground
-#define FL_SWIM		(1<<1)	// Changes the SV_Movestep() behavior to not need to be on ground (but stay in water)
+#define FL_SWIM		(1U<<1)	// Changes the SV_Movestep() behavior to not need to be on ground (but stay in water)
-#define FL_CONVEYOR		(1<<2)
+#define FL_CONVEYOR		(1U<<2)
-#define FL_CLIENT		(1<<3)
+#define FL_CLIENT		(1U<<3)
-#define FL_INWATER		(1<<4)
+#define FL_INWATER		(1U<<4)
-#define FL_MONSTER		(1<<5)
+#define FL_MONSTER		(1U<<5)
-#define FL_GODMODE		(1<<6)
+#define FL_GODMODE		(1U<<6)
-#define FL_NOTARGET		(1<<7)
+#define FL_NOTARGET		(1U<<7)
-#define FL_SKIPLOCALHOST	(1<<8)	// Don't send entity to local host, it's predicting this entity itself
+#define FL_SKIPLOCALHOST	(1U<<8)	// Don't send entity to local host, it's predicting this entity itself
-#define FL_ONGROUND		(1<<9)	// At rest / on the ground
+#define FL_ONGROUND		(1U<<9)	// At rest / on the ground
-#define FL_PARTIALGROUND	(1<<10)	// not all corners are valid
+#define FL_PARTIALGROUND	(1U<<10)	// not all corners are valid
-#define FL_WATERJUMP	(1<<11)	// player jumping out of water
+#define FL_WATERJUMP	(1U<<11)	// player jumping out of water
-#define FL_FROZEN		(1<<12)	// Player is frozen for 3rd person camera
+#define FL_FROZEN		(1U<<12)	// Player is frozen for 3rd person camera
-#define FL_FAKECLIENT	(1<<13)	// JAC: fake client, simulated server side; don't send network messages to them
+#define FL_FAKECLIENT	(1U<<13)	// JAC: fake client, simulated server side; don't send network messages to them
-#define FL_DUCKING		(1<<14)	// Player flag -- Player is fully crouched
+#define FL_DUCKING		(1U<<14)	// Player flag -- Player is fully crouched
-#define FL_FLOAT		(1<<15)	// Apply floating force to this entity when in water
+#define FL_FLOAT		(1U<<15)	// Apply floating force to this entity when in water
-#define FL_GRAPHED		(1<<16)	// worldgraph has this ent listed as something that blocks a connection
+#define FL_GRAPHED		(1U<<16)	// worldgraph has this ent listed as something that blocks a connection
 
 // UNDONE: Do we need these?
-#define FL_IMMUNE_WATER	(1<<17)
+#define FL_IMMUNE_WATER	(1U<<17)
-#define FL_IMMUNE_SLIME	(1<<18)
+#define FL_IMMUNE_SLIME	(1U<<18)
-#define FL_IMMUNE_LAVA	(1<<19)
+#define FL_IMMUNE_LAVA	(1U<<19)
 
-#define FL_PROXY		(1<<20)	// This is a spectator proxy
+#define FL_PROXY		(1U<<20)	// This is a spectator proxy
-#define FL_ALWAYSTHINK	(1<<21)	// Brush model flag -- call think every frame regardless of nextthink - ltime (for constantly changing velocity/path)
+#define FL_ALWAYSTHINK	(1U<<21)	// Brush model flag -- call think every frame regardless of nextthink - ltime (for constantly changing velocity/path)
-#define FL_BASEVELOCITY	(1<<22)	// Base velocity has been applied this frame (used to convert base velocity into momentum)
+#define FL_BASEVELOCITY	(1U<<22)	// Base velocity has been applied this frame (used to convert base velocity into momentum)
-#define FL_MONSTERCLIP	(1<<23)	// Only collide in with monsters who have FL_MONSTERCLIP set
+#define FL_MONSTERCLIP	(1U<<23)	// Only collide in with monsters who have FL_MONSTERCLIP set
-#define FL_ONTRAIN		(1<<24)	// Player is _controlling_ a train, so movement commands should be ignored on client during prediction.
+#define FL_ONTRAIN		(1U<<24)	// Player is _controlling_ a train, so movement commands should be ignored on client during prediction.
-#define FL_WORLDBRUSH	(1<<25)	// Not moveable/removeable brush entity (really part of the world, but represented as an entity for transparency or something)
+#define FL_WORLDBRUSH	(1U<<25)	// Not moveable/removeable brush entity (really part of the world, but represented as an entity for transparency or something)
-#define FL_SPECTATOR	(1<<26)	// This client is a spectator, don't run touch functions, etc.
+#define FL_SPECTATOR	(1U<<26)	// This client is a spectator, don't run touch functions, etc.
-#define FL_LASERDOT		(1<<27)	// Predicted laser spot from rocket launcher
+#define FL_LASERDOT		(1U<<27)	// Predicted laser spot from rocket launcher
 
-#define FL_CUSTOMENTITY	(1<<29)	// This is a custom entity
+#define FL_CUSTOMENTITY	(1U<<29)	// This is a custom entity
-#define FL_KILLME		(1<<30)	// This entity is marked for death -- This allows the engine to kill ents at the appropriate time
+#define FL_KILLME		(1U<<30)	// This entity is marked for death -- This allows the engine to kill ents at the appropriate time
-#define FL_DORMANT		(1<<31)	// Entity is dormant, no updates to client
+#define FL_DORMANT		(1U<<31)	// Entity is dormant, no updates to client
 
 // Goes into globalvars_t.trace_flags
-#define FTRACE_SIMPLEBOX		(1<<0)	// Traceline with a simple box
+#define FTRACE_SIMPLEBOX		(1U<<0)	// Traceline with a simple box
-#define FTRACE_IGNORE_GLASS		(1<<1)	// traceline will be ignored entities with rendermode != kRenderNormal
+#define FTRACE_IGNORE_GLASS		(1U<<1)	// traceline will be ignored entities with rendermode != kRenderNormal
 
 // walkmove modes
 #define WALKMOVE_NORMAL		0	// normal walkmove
@@ -114,11 +114,11 @@
 #define EF_LIGHT			64	// rocket flare glow sprite
 #define EF_NODRAW			128	// don't draw entity
 
-#define EF_WATERSIDES		(1<<26)	// Do not remove sides for func_water entity
+#define EF_WATERSIDES		(1U<<26)	// Do not remove sides for func_water entity
-#define EF_FULLBRIGHT		(1<<27)	// Just get fullbright
+#define EF_FULLBRIGHT		(1U<<27)	// Just get fullbright
-#define EF_NOSHADOW			(1<<28)	// ignore shadow for this entity
+#define EF_NOSHADOW			(1U<<28)	// ignore shadow for this entity
-#define EF_MERGE_VISIBILITY		(1<<29)	// this entity allowed to merge vis (e.g. env_sky or portal camera)
+#define EF_MERGE_VISIBILITY		(1U<<29)	// this entity allowed to merge vis (e.g. env_sky or portal camera)
-#define EF_REQUEST_PHS		(1<<30)	// This entity requested phs bitvector instead of pvsbitvector in AddToFullPack calls
+#define EF_REQUEST_PHS		(1U<<30)	// This entity requested phs bitvector instead of pvsbitvector in AddToFullPack calls
 // g-cont. one reserved bit here for me
 
 // entity flags
@@ -606,13 +606,6 @@
 #define CONTENT_GRAVITY_FLYFIELD	-18
 #define CONTENT_FOG			-19
 
-#define CONTENT_EMPTY		-1
-#define CONTENT_SOLID		-2
-#define CONTENT_WATER		-3
-#define CONTENT_SLIME		-4
-#define CONTENT_LAVA		-5
-#define CONTENT_SKY			-6
-
 // channels
 #define CHAN_AUTO			0
 #define CHAN_WEAPON			1
@@ -647,22 +640,22 @@
 #define SF_TRAIN_PASSABLE		8	// Train is not solid -- used to make water trains
 
 // buttons
-#define IN_ATTACK			(1<<0)
+#define IN_ATTACK			(1U<<0)
-#define IN_JUMP			(1<<1)
+#define IN_JUMP			(1U<<1)
-#define IN_DUCK			(1<<2)
+#define IN_DUCK			(1U<<2)
-#define IN_FORWARD			(1<<3)
+#define IN_FORWARD			(1U<<3)
-#define IN_BACK			(1<<4)
+#define IN_BACK			(1U<<4)
-#define IN_USE			(1<<5)
+#define IN_USE			(1U<<5)
-#define IN_CANCEL			(1<<6)
+#define IN_CANCEL			(1U<<6)
-#define IN_LEFT			(1<<7)
+#define IN_LEFT			(1U<<7)
-#define IN_RIGHT			(1<<8)
+#define IN_RIGHT			(1U<<8)
-#define IN_MOVELEFT			(1<<9)
+#define IN_MOVELEFT			(1U<<9)
-#define IN_MOVERIGHT		(1<<10)
+#define IN_MOVERIGHT		(1U<<10)
-#define IN_ATTACK2			(1<<11)
+#define IN_ATTACK2			(1U<<11)
-#define IN_RUN			(1<<12)
+#define IN_RUN			(1U<<12)
-#define IN_RELOAD			(1<<13)
+#define IN_RELOAD			(1U<<13)
-#define IN_ALT1			(1<<14)
+#define IN_ALT1			(1U<<14)
-#define IN_SCORE			(1<<15)   // Used by client.dll for when scoreboard is held down
+#define IN_SCORE			(1U<<15)   // Used by client.dll for when scoreboard is held down
 
 // Break Model Defines
 #define BREAK_TYPEMASK		0x4F
@@ -729,19 +722,9 @@ enum
 typedef int		func_t;
 typedef int		string_t;
 
-typedef unsigned char	byte;
 typedef unsigned short	word;
 
-#define Q_isspace( ch )	(ch < 32 || ch > 255)
+#include "xash3d_types.h"
-
-#undef true
-#undef false
-
-#ifndef __cplusplus
-typedef enum { false, true }	qboolean;
-#else 
-typedef int qboolean;
-#endif
 
 typedef struct
 {

common/cvardef.h

@@ -25,14 +25,18 @@
 #define FCVAR_PRINTABLEONLY		(1<<7)	// This cvar's string cannot contain unprintable characters ( e.g., used for player name etc ).
 #define FCVAR_UNLOGGED		(1<<8)	// If this is a FCVAR_SERVER, don't log changes to the log file / console if we are creating a log
 #define FCVAR_NOEXTRAWHITEPACE	(1<<9)	// strip trailing/leading white space from this cvar
+#define FCVAR_PRIVILEGED	(1<<10) // only available in privileged mode
+#define FCVAR_FILTERABLE	(1<<11) // filtered in unprivileged mode if cl_filterstuffcmd is 1
 
-#define FCVAR_MOVEVARS		(1<<10)	// this cvar is a part of movevars_t struct that shared between client and server
+// Xash3D extensions
-#define FCVAR_LATCH			(1<<11)	// notify client what this cvar will be applied only after server restart (but don't does more nothing)
+#define FCVAR_GLCONFIG		(1<<12)	// write it into <renderer>.cfg(see RefAPI)
-#define FCVAR_GLCONFIG		(1<<12)	// write it into opengl.cfg
 #define FCVAR_CHANGED		(1<<13)	// set each time the cvar is changed
 #define FCVAR_GAMEUIDLL		(1<<14)	// defined by the menu DLL
 #define FCVAR_CHEAT			(1<<15)	// can not be changed if cheats are disabled
 
+// a1ba: let's reuse higher bits for flags extensions from now on
+#define FCVAR_LATCH			(1<<30)	// notify client what this cvar will be applied only after server restart (but don't does more nothing)
+
 typedef struct cvar_s
 {
 	char		*name;

common/defaults.h

@@ -0,0 +1,196 @@
+/*
+defaults.h - set up default configuration
+Copyright (C) 2016 Mittorn
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+*/
+
+#ifndef DEFAULTS_H
+#define DEFAULTS_H
+
+#include "backends.h"
+#include "build.h"
+
+/*
+===================================================================
+
+SETUP BACKENDS DEFINITIONS
+
+===================================================================
+*/
+#if !XASH_DEDICATED
+	#if XASH_SDL
+		// we are building using libSDL
+		#ifndef XASH_VIDEO
+			#define XASH_VIDEO VIDEO_SDL
+		#endif // XASH_VIDEO
+
+		#ifndef XASH_INPUT
+			#define XASH_INPUT INPUT_SDL
+		#endif // XASH_INPUT
+
+		#ifndef XASH_SOUND
+			#define XASH_SOUND SOUND_SDL
+		#endif // XASH_SOUND
+
+		#if XASH_SDL == 2
+			#ifndef XASH_TIMER
+				#define XASH_TIMER TIMER_SDL
+			#endif // XASH_TIMER
+
+			#ifndef XASH_MESSAGEBOX
+				#if !XASH_NSWITCH // SDL2 messageboxes not available
+					#define XASH_MESSAGEBOX MSGBOX_SDL
+				#endif
+			#endif // XASH_MESSAGEBOX
+		#endif
+	#elif XASH_LINUX
+		// we are building for Linux without SDL2, can draw only to framebuffer yet
+		#ifndef XASH_VIDEO
+			#define XASH_VIDEO VIDEO_FBDEV
+		#endif // XASH_VIDEO
+
+		#ifndef XASH_INPUT
+			#define XASH_INPUT INPUT_EVDEV
+		#endif // XASH_INPUT
+
+		#ifndef XASH_SOUND
+			#define XASH_SOUND SOUND_ALSA
+		#endif // XASH_SOUND
+
+		#define XASH_USE_EVDEV 1
+	#elif XASH_DOS4GW
+		#ifndef XASH_VIDEO
+			#define XASH_VIDEO VIDEO_DOS
+		#endif
+		#ifndef XASH_TIMER
+			#define XASH_TIMER TIMER_DOS
+		#endif
+
+		// usually only 10-20 fds availiable
+		#define XASH_REDUCE_FD
+	#endif
+
+#endif // XASH_DEDICATED
+
+//
+// select messagebox implementation
+//
+#ifndef XASH_MESSAGEBOX
+	#if XASH_WIN32
+		#define XASH_MESSAGEBOX MSGBOX_WIN32
+	#elif XASH_NSWITCH
+		#define XASH_MESSAGEBOX MSGBOX_NSWITCH
+	#else // !XASH_WIN32
+		#define XASH_MESSAGEBOX MSGBOX_STDERR
+	#endif // !XASH_WIN32
+#endif // XASH_MESSAGEBOX
+
+//
+// no timer - no xash
+//
+#ifndef XASH_TIMER
+	#if XASH_WIN32
+		#define XASH_TIMER TIMER_WIN32
+	#else // !XASH_WIN32
+		#define XASH_TIMER TIMER_POSIX
+	#endif // !XASH_WIN32
+#endif
+
+#ifdef XASH_STATIC_LIBS
+#define XASH_LIB LIB_STATIC
+#define XASH_INTERNAL_GAMELIBS
+#define XASH_ALLOW_SAVERESTORE_OFFSETS
+#elif XASH_WIN32
+#define XASH_LIB LIB_WIN32
+#elif XASH_POSIX
+#define XASH_LIB LIB_POSIX
+#endif
+
+//
+// fallback to NULL
+//
+#ifndef XASH_VIDEO
+	#define XASH_VIDEO VIDEO_NULL
+#endif // XASH_VIDEO
+
+#ifndef XASH_SOUND
+	#define XASH_SOUND SOUND_NULL
+#endif // XASH_SOUND
+
+#ifndef XASH_INPUT
+	#define XASH_INPUT INPUT_NULL
+#endif // XASH_INPUT
+
+/*
+=========================================================================
+
+Default build-depended cvar and constant values
+
+=========================================================================
+*/
+
+// Platform overrides
+#if XASH_NSWITCH
+	#define DEFAULT_TOUCH_ENABLE "0"
+	#define DEFAULT_M_IGNORE     "1"
+	#define DEFAULT_MODE_WIDTH   1280
+	#define DEFAULT_MODE_HEIGHT  720
+	#define DEFAULT_ALLOWCONSOLE 1
+#elif XASH_PSVITA
+	#define DEFAULT_TOUCH_ENABLE "0"
+	#define DEFAULT_M_IGNORE     "1"
+	#define DEFAULT_MODE_WIDTH   960
+	#define DEFAULT_MODE_HEIGHT  544
+	#define DEFAULT_ALLOWCONSOLE 1
+#elif XASH_ANDROID
+	#define DEFAULT_TOUCH_ENABLE "1"
+#elif XASH_MOBILE_PLATFORM
+	#define DEFAULT_TOUCH_ENABLE "1"
+	#define DEFAULT_M_IGNORE     "1"
+#endif // !XASH_MOBILE_PLATFORM && !XASH_NSWITCH
+
+#if XASH_ANDROID || XASH_IOS || XASH_EMSCRIPTEN
+	// this means that libraries are provided with engine, but not in game data
+	// You need add library loading code to library.c when adding new platform
+	#define XASH_INTERNAL_GAMELIBS
+#endif // XASH_ANDROID || XASH_IOS || XASH_EMSCRIPTEN
+
+// Defaults
+#ifndef DEFAULT_TOUCH_ENABLE
+	#define DEFAULT_TOUCH_ENABLE "0"
+#endif // DEFAULT_TOUCH_ENABLE
+
+#ifndef DEFAULT_M_IGNORE
+	#define DEFAULT_M_IGNORE "0"
+#endif // DEFAULT_M_IGNORE
+
+#ifndef DEFAULT_JOY_DEADZONE
+	#define DEFAULT_JOY_DEADZONE "4096"
+#endif // DEFAULT_JOY_DEADZONE
+
+#ifndef DEFAULT_DEV
+	#define DEFAULT_DEV 0
+#endif // DEFAULT_DEV
+
+#ifndef DEFAULT_ALLOWCONSOLE
+	#define DEFAULT_ALLOWCONSOLE 0
+#endif // DEFAULT_ALLOWCONSOLE
+
+#ifndef DEFAULT_FULLSCREEN
+	#define DEFAULT_FULLSCREEN "1" // must be a string
+#endif // DEFAULT_FULLSCREEN
+
+#ifndef DEFAULT_MAX_EDICTS
+	#define DEFAULT_MAX_EDICTS 1200 // was 900 before HL25
+#endif // DEFAULT_MAX_EDICTS
+
+#endif // DEFAULTS_H

common/enginefeatures.h

@@ -25,5 +25,6 @@ GNU General Public License for more details.
 #define ENGINE_COMPENSATE_QUAKE_BUG	(1<<5)	// compensate stupid quake bug (inverse pitch) for mods where this bug is fixed
 #define ENGINE_IMPROVED_LINETRACE	(1<<6)	// new traceline that tracing through alphatextures
 #define ENGINE_COMPUTE_STUDIO_LERP	(1<<7)	// enable MOVETYPE_STEP lerping back in engine
+#define ENGINE_LINEAR_GAMMA_SPACE	(1<<8)	// disable influence of gamma/brightness cvars to textures/lightmaps, for mods with custom renderer
 
 #endif//FEATURES_H

common/gameinfo.h

@@ -18,6 +18,9 @@ GNU General Public License for more details.
 
 #define GFL_NOMODELS	(1<<0)
 #define GFL_NOSKILLS	(1<<1)
+#define GFL_RENDER_PICBUTTON_TEXT   (1<<2)
+#define GFL_HD_BACKGROUND (1<<3)
+#define GFL_ANIMATED_TITLE (1<<4)
 
 /*
 ========================================================================

common/kbutton.h

@@ -0,0 +1,18 @@
+//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose:
+//
+// $NoKeywords: $
+//=============================================================================
+
+#if !defined( KBUTTONH )
+#define KBUTTONH
+#pragma once
+
+typedef struct kbutton_s
+{
+	int		down[2];		// key nums holding it down
+	int		state;			// low bit is down state
+} kbutton_t;
+
+#endif // !KBUTTONH

common/net_api.h

@@ -28,6 +28,7 @@
 // kill the request hook after receiving the first response
 #define FNETAPI_MULTIPLE_RESPONSE		( 1<<0 )
 
+struct net_response_s;
 typedef void (*net_api_response_func_t) ( struct net_response_s *response );
 
 #define NET_SUCCESS				( 0 )
@@ -86,7 +87,7 @@ typedef struct net_api_s
 	void		(*SendRequest)( int context, int request, int flags, double timeout, struct netadr_s *remote_address, net_api_response_func_t response );
 	void		(*CancelRequest)( int context );
 	void		(*CancelAllRequests)( void );
-	char		*(*AdrToString)( struct netadr_s *a );
+	const char	*(*AdrToString)( struct netadr_s *a );
 	int		( *CompareAdr)( struct netadr_s *a, struct netadr_s *b );
 	int		( *StringToAdr)( char *s, struct netadr_s *a );
 	const char	*(*ValueForKey)( const char *s, const char *key );

common/netadr.h

@@ -16,22 +16,61 @@
 #ifndef NETADR_H
 #define NETADR_H
 
+#include "build.h"
+#include STDINT_H
+
 typedef enum
 {
-	NA_UNUSED,
+	NA_UNUSED = 0,
 	NA_LOOPBACK,
 	NA_BROADCAST,
 	NA_IP,
 	NA_IPX,
-	NA_BROADCAST_IPX
+	NA_BROADCAST_IPX,
+	NA_IP6,
+	NA_MULTICAST_IP6, // all nodes multicast
 } netadrtype_t;
 
+// Original structure:
+// typedef struct netadr_s
+// {
+// 	netadrtype_t	type;
+// 	unsigned char	ip[4];
+// 	unsigned char	ipx[10];
+// 	unsigned short	port;
+// } netadr_t;
+
+#pragma pack( push, 1 )
 typedef struct netadr_s
 {
-	netadrtype_t	type;
+	union
-	unsigned char	ip[4];
+	{
-	unsigned char	ipx[10];
+		struct
-	unsigned short	port;
+		{
+			uint32_t type;
+			union
+			{
+				uint8_t   ip[4];
+				uint32_t  ip4;
+			};
+			uint8_t  ipx[10];
+		};
+		struct
+		{
+#if XASH_LITTLE_ENDIAN
+			uint16_t type6;
+			uint8_t ip6[16];
+#elif XASH_BIG_ENDIAN
+			uint8_t ip6_0[2];
+			uint16_t type6;
+			uint8_t ip6_2[14];
+#endif
+		};
+	};
+	uint16_t port;
 } netadr_t;
+#pragma pack( pop )
+
+STATIC_ASSERT( sizeof( netadr_t ) == 20, "invalid netadr_t size" );
 
 #endif//NETADR_H

common/port.h

@@ -0,0 +1,101 @@
+/*
+port.h -- Portability Layer for Windows types
+Copyright (C) 2015 Alibek Omarov
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+*/
+
+#pragma once
+#ifndef PORT_H
+#define PORT_H
+
+#include "build.h"
+
+#if !XASH_WIN32
+	#if XASH_APPLE
+		#include <sys/syslimits.h>
+		#define OS_LIB_EXT "dylib"
+		#define OPEN_COMMAND "open"
+	#else
+		#define OS_LIB_EXT "so"
+		#define OPEN_COMMAND "xdg-open"
+	#endif
+	#define OS_LIB_PREFIX "lib"
+	#define VGUI_SUPPORT_DLL "libvgui_support." OS_LIB_EXT
+
+	// Windows-specific
+	#define __cdecl
+	#define __stdcall
+	#define _inline	static inline
+	#define FORCEINLINE inline __attribute__((always_inline))
+
+	#if XASH_POSIX
+		#include <unistd.h>
+		#if XASH_NSWITCH
+			#define SOLDER_LIBDL_COMPAT
+			#include <solder.h>
+		#elif XASH_PSVITA
+			#define VRTLD_LIBDL_COMPAT
+			#include <vrtld.h>
+			#define O_BINARY 0
+		#else
+			#include <dlfcn.h>
+			#define HAVE_DUP
+			#define O_BINARY 0
+		#endif
+		#define O_TEXT 0
+		#define _mkdir( x ) mkdir( x, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH )
+	#endif
+
+	typedef void* HANDLE;
+	typedef void* HINSTANCE;
+
+	typedef struct tagPOINT
+	{
+		int x, y;
+	} POINT;
+#else // WIN32
+	#ifdef __MINGW32__
+		#define _inline static inline
+		#define FORCEINLINE inline __attribute__((always_inline))
+	#else
+		#define FORCEINLINE __forceinline
+	#endif
+
+	#define open _open
+	#define read _read
+	#define alloca _alloca
+
+	#define HSPRITE WINAPI_HSPRITE
+		#define WIN32_LEAN_AND_MEAN
+		#include <winsock2.h>
+		#include <windows.h>
+	#undef HSPRITE
+
+	#define OS_LIB_PREFIX ""
+	#define OS_LIB_EXT "dll"
+	#define VGUI_SUPPORT_DLL "../vgui_support." OS_LIB_EXT
+	#define HAVE_DUP
+#endif //WIN32
+
+#ifndef XASH_LOW_MEMORY
+#define XASH_LOW_MEMORY 0
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+#if defined XASH_SDL && !defined REF_DLL
+#include <SDL.h>
+#endif
+
+#endif // PORT_H

common/r_efx.h

@@ -84,7 +84,7 @@ color24 gTracerColors[] =
 #define FTENT_CLIENTCUSTOM		0x00080000 // Must specify callback.  Callback function is responsible for killing tempent and updating fields ( unless other flags specify how to do things )
 #define FTENT_SCALE			0x00100000 // An experiment
 
-typedef struct tempent_s	TEMPENTITY;
+struct pmtrace_s;
 typedef struct tempent_s
 {
 	int		flags;
@@ -98,7 +98,7 @@ typedef struct tempent_s
 	int		hitSound;
 	void		(*hitcallback)( struct tempent_s *ent, struct pmtrace_s *ptr );
 	void		(*callback)( struct tempent_s *ent, float frametime, float currenttime );
-	TEMPENTITY	*next;
+	struct tempent_s	*next;
 	int		priority;
 	short		clientIndex;	// if attached, this is the index of the client to stick to
 					// if COLLIDEALL, this is the index of the client to ignore
@@ -117,58 +117,58 @@ typedef struct efx_api_s efx_api_t;
 struct efx_api_s
 {
 	particle_t	*(*R_AllocParticle)( void (*callback)( struct particle_s *particle, float frametime ));
-	void		(*R_BlobExplosion)( float *org );
+	void		(*R_BlobExplosion)( const float *org );
-	void		(*R_Blood)( float *org, float *dir, int pcolor, int speed );
+	void		(*R_Blood)( const float *org, const float *dir, int pcolor, int speed );
-	void		(*R_BloodSprite)( float *org, int colorindex, int modelIndex, int modelIndex2, float size );
+	void		(*R_BloodSprite)( const float *org, int colorindex, int modelIndex, int modelIndex2, float size );
-	void		(*R_BloodStream)( float *org, float *dir, int pcolor, int speed );
+	void		(*R_BloodStream)( const float *org, const float *dir, int pcolor, int speed );
-	void		(*R_BreakModel)( float *pos, float *size, float *dir, float random, float life, int count, int modelIndex, char flags );
+	void		(*R_BreakModel)( const float *pos, const float *size, const float *dir, float random, float life, int count, int modelIndex, char flags );
-	void		(*R_Bubbles)( float *mins, float *maxs, float height, int modelIndex, int count, float speed );
+	void		(*R_Bubbles)( const float *mins, const float *maxs, float height, int modelIndex, int count, float speed );
-	void		(*R_BubbleTrail)( float *start, float *end, float height, int modelIndex, int count, float speed );
+	void		(*R_BubbleTrail)( const float *start, const float *end, float height, int modelIndex, int count, float speed );
-	void		(*R_BulletImpactParticles)( float *pos );
+	void		(*R_BulletImpactParticles)( const float *pos );
 	void		(*R_EntityParticles)( struct cl_entity_s *ent );
 	void		(*R_Explosion)( float *pos, int model, float scale, float framerate, int flags );
 	void		(*R_FizzEffect)( struct cl_entity_s *pent, int modelIndex, int density );
 	void		(*R_FireField)( float *org, int radius, int modelIndex, int count, int flags, float life );
-	void		(*R_FlickerParticles)( float *org );
+	void		(*R_FlickerParticles)( const float *org );
-	void		(*R_FunnelSprite)( float *org, int modelIndex, int reverse );
+	void		(*R_FunnelSprite)( const float *org, int modelIndex, int reverse );
-	void		(*R_Implosion)( float *end, float radius, int count, float life );
+	void		(*R_Implosion)( const float *end, float radius, int count, float life );
-	void		(*R_LargeFunnel)( float *org, int reverse );
+	void		(*R_LargeFunnel)( const float *org, int reverse );
-	void		(*R_LavaSplash)( float *org );
+	void		(*R_LavaSplash)( const float *org );
-	void		(*R_MultiGunshot)( float *org, float *dir, float *noise, int count, int decalCount, int *decalIndices );
+	void		(*R_MultiGunshot)( const float *org, const float *dir, const float *noise, int count, int decalCount, int *decalIndices );
-	void		(*R_MuzzleFlash)( float *pos1, int type );
+	void		(*R_MuzzleFlash)( const float *pos1, int type );
-	void		(*R_ParticleBox)( float *mins, float *maxs, unsigned char r, unsigned char g, unsigned char b, float life );
+	void		(*R_ParticleBox)( const float *mins, const float *maxs, unsigned char r, unsigned char g, unsigned char b, float life );
-	void		(*R_ParticleBurst)( float *pos, int size, int color, float life );
+	void		(*R_ParticleBurst)( const float *pos, int size, int color, float life );
-	void		(*R_ParticleExplosion)( float *org );
+	void		(*R_ParticleExplosion)( const float *org );
-	void		(*R_ParticleExplosion2)( float *org, int colorStart, int colorLength );
+	void		(*R_ParticleExplosion2)( const float *org, int colorStart, int colorLength );
-	void		(*R_ParticleLine)( float *start, float *end, unsigned char r, unsigned char g, unsigned char b, float life );
+	void		(*R_ParticleLine)( const float *start, const float *end, unsigned char r, unsigned char g, unsigned char b, float life );
 	void		(*R_PlayerSprites)( int client, int modelIndex, int count, int size );
-	void		(*R_Projectile)( float *origin, float *velocity, int modelIndex, int life, int owner, void (*hitcallback)( struct tempent_s *ent, struct pmtrace_s *ptr ) );
+	void		(*R_Projectile)( const float *origin, const float *velocity, int modelIndex, int life, int owner, void (*hitcallback)( struct tempent_s *ent, struct pmtrace_s *ptr ) );
-	void		(*R_RicochetSound)( float *pos );
+	void		(*R_RicochetSound)( const float *pos );
-	void		(*R_RicochetSprite)( float *pos, struct model_s *pmodel, float duration, float scale );
+	void		(*R_RicochetSprite)( const float *pos, struct model_s *pmodel, float duration, float scale );
-	void		(*R_RocketFlare)( float *pos );
+	void		(*R_RocketFlare)( const float *pos );
 	void		(*R_RocketTrail)( float *start, float *end, int type );
-	void		(*R_RunParticleEffect)( float *org, float *dir, int color, int count );
+	void		(*R_RunParticleEffect)( const float *org, const float *dir, int color, int count );
-	void		(*R_ShowLine)( float *start, float *end );
+	void		(*R_ShowLine)( const float *start, const float *end );
-	void		(*R_SparkEffect)( float *pos, int count, int velocityMin, int velocityMax );
+	void		(*R_SparkEffect)( const float *pos, int count, int velocityMin, int velocityMax );
-	void		(*R_SparkShower)( float *pos );
+	void		(*R_SparkShower)( const float *pos );
-	void		(*R_SparkStreaks)( float *pos, int count, int velocityMin, int velocityMax );
+	void		(*R_SparkStreaks)( const float *pos, int count, int velocityMin, int velocityMax );
-	void		(*R_Spray)( float *pos, float *dir, int modelIndex, int count, int speed, int spread, int rendermode );
+	void		(*R_Spray)( const float *pos, const float *dir, int modelIndex, int count, int speed, int spread, int rendermode );
 	void		(*R_Sprite_Explode)( TEMPENTITY *pTemp, float scale, int flags );
 	void		(*R_Sprite_Smoke)( TEMPENTITY *pTemp, float scale );
-	void		(*R_Sprite_Spray)( float *pos, float *dir, int modelIndex, int count, int speed, int iRand );
+	void		(*R_Sprite_Spray)( const float *pos, const float *dir, int modelIndex, int count, int speed, int iRand );
 	void		(*R_Sprite_Trail)( int type, float *start, float *end, int modelIndex, int count, float life, float size, float amplitude, int renderamt, float speed );
 	void		(*R_Sprite_WallPuff)( TEMPENTITY *pTemp, float scale );
-	void		(*R_StreakSplash)( float *pos, float *dir, int color, int count, float speed, int velocityMin, int velocityMax );
+	void		(*R_StreakSplash)( const float *pos, const float *dir, int color, int count, float speed, int velocityMin, int velocityMax );
-	void		(*R_TracerEffect)( float *start, float *end );
+	void		(*R_TracerEffect)( const float *start, const float *end );
 	void		(*R_UserTracerParticle)( float *org, float *vel, float life, int colorIndex, float length, unsigned char deathcontext, void (*deathfunc)( struct particle_s *particle ));
 	particle_t	*(*R_TracerParticles)( float *org, float *vel, float life );
-	void		(*R_TeleportSplash)( float *org );
+	void		(*R_TeleportSplash)( const float *org );
-	void		(*R_TempSphereModel)( float *pos, float speed, float life, int count, int modelIndex );
+	void		(*R_TempSphereModel)( const float *pos, float speed, float life, int count, int modelIndex );
-	TEMPENTITY	*(*R_TempModel)( float *pos, float *dir, float *angles, float life, int modelIndex, int soundtype );
+	TEMPENTITY	*(*R_TempModel)( const float *pos, const float *dir, const float *angles, float life, int modelIndex, int soundtype );
-	TEMPENTITY	*(*R_DefaultSprite)( float *pos, int spriteIndex, float framerate );
+	TEMPENTITY	*(*R_DefaultSprite)( const float *pos, int spriteIndex, float framerate );
-	TEMPENTITY	*(*R_TempSprite)( float *pos, float *dir, float scale, int modelIndex, int rendermode, int renderfx, float a, float life, int flags );
+	TEMPENTITY	*(*R_TempSprite)( float *pos, const float *dir, float scale, int modelIndex, int rendermode, int renderfx, float a, float life, int flags );
 	int		(*Draw_DecalIndex)( int id );
-	int		(*Draw_DecalIndexFromName)( char *name );
+	int		(*Draw_DecalIndexFromName)( const char *name );
 	void		(*R_DecalShoot)( int textureIndex, int entity, int modelIndex, float *position, int flags );
 	void		(*R_AttachTentToPlayer)( int client, int modelIndex, float zoffset, float life );
 	void		(*R_KillAttachedTents)( int client );
@@ -182,10 +182,10 @@ struct efx_api_s
 	BEAM		*(*R_BeamRing)( int startEnt, int endEnt, int modelIndex, float life, float width, float amplitude, float brightness, float speed, int startFrame, float framerate, float r, float g, float b );
 	dlight_t		*(*CL_AllocDlight)( int key );
 	dlight_t		*(*CL_AllocElight)( int key );
-	TEMPENTITY	*(*CL_TempEntAlloc)( float *org, struct model_s *model );
+	TEMPENTITY	*(*CL_TempEntAlloc)( const float *org, struct model_s *model );
-	TEMPENTITY	*(*CL_TempEntAllocNoModel)( float *org );
+	TEMPENTITY	*(*CL_TempEntAllocNoModel)( const float *org );
-	TEMPENTITY	*(*CL_TempEntAllocHigh)( float *org, struct model_s *model );
+	TEMPENTITY	*(*CL_TempEntAllocHigh)( const float *org, struct model_s *model );
-	TEMPENTITY	*(*CL_TentEntAllocCustom)( float *origin, struct model_s *model, int high, void (*callback)( struct tempent_s *ent, float frametime, float currenttime ));
+	TEMPENTITY	*(*CL_TentEntAllocCustom)( const float *origin, struct model_s *model, int high, void (*callback)( struct tempent_s *ent, float frametime, float currenttime ));
 	void		(*R_GetPackedColor)( short *packed, short color );
 	short		(*R_LookupColor)( unsigned char r, unsigned char g, unsigned char b );
 	void		(*R_DecalRemoveAll)( int textureIndex ); // textureIndex points to the decal index in the array, not the actual texture index.

common/r_studioint.h

@@ -26,7 +26,7 @@ typedef struct engine_studio_api_s
 	// Check to see if pointer is in the cache
 	void		*( *Cache_Check )( struct cache_user_s *c );
 	// Load file into cache ( can be swapped out on demand )
-	void		( *LoadCacheFile )( char *path, struct cache_user_s *cu );
+	void		( *LoadCacheFile )( const char *path, struct cache_user_s *cu );
 	// Retrieve model pointer for the named model
 	struct model_s	*( *Mod_ForName )( const char *name, int crash_if_missing );
 	// Retrieve pointer to studio model data block from a model
@@ -120,7 +120,7 @@ typedef struct server_studio_api_s
 	// Check to see if pointer is in the cache
 	void		*( *Cache_Check )( struct cache_user_s *c );
 	// Load file into cache ( can be swapped out on demand )
-	void		( *LoadCacheFile )( char *path, struct cache_user_s *cu );
+	void		( *LoadCacheFile )( const char *path, struct cache_user_s *cu );
 	// Retrieve pointer to studio model data block from a model
 	void		*( *Mod_Extradata )( struct model_s *mod );
 } server_studio_api_t;

common/render_api.h

@@ -82,7 +82,7 @@ typedef enum
 	TF_KEEP_SOURCE	= (1<<1),		// some images keep source
 	TF_NOFLIP_TGA	= (1<<2),		// Steam background completely ignore tga attribute 0x20
 	TF_EXPAND_SOURCE	= (1<<3),		// Don't keep source as 8-bit expand to RGBA
-	TF_ALLOW_EMBOSS	= (1<<4),		// Allow emboss-mapping for this image
+// reserved
 	TF_RECTANGLE	= (1<<5),		// this is GL_TEXTURE_RECTANGLE
 	TF_CUBEMAP	= (1<<6),		// it's cubemap texture
 	TF_DEPTHMAP	= (1<<7),		// custom texture filter used
@@ -107,19 +107,23 @@ typedef enum
 	TF_ARB_FLOAT	= (1<<26),	// float textures
 	TF_NOCOMPARE	= (1<<27),	// disable comparing for depth textures
 	TF_ARB_16BIT	= (1<<28),	// keep image as 16-bit (not 24)
+	TF_MULTISAMPLE	= (1<<29)	// multisampling texture
 } texFlags_t;
 
 typedef enum
 {
-	CONTEXT_TYPE_GL = 0,
+	CONTEXT_TYPE_GL = 0, // compatibility profile
 	CONTEXT_TYPE_GLES_1_X,
-	CONTEXT_TYPE_GLES_2_X
+	CONTEXT_TYPE_GLES_2_X,
+	CONTEXT_TYPE_GL_CORE
 } gl_context_type_t;
 
 typedef enum
 {
-	GLES_WRAPPER_NONE = 0,		// native GLES
+	GLES_WRAPPER_NONE = 0,		// native GL
 	GLES_WRAPPER_NANOGL,		// used on GLES platforms
+	GLES_WRAPPER_WES,		// used on GLES platforms
+	GLES_WRAPPER_GL4ES,		// used on GLES platforms
 } gles_wrapper_t;
 
 // 30 bytes here
@@ -152,10 +156,12 @@ typedef struct decallist_s
 	modelstate_t	studio_state;	// studio decals only
 } decallist_t;
 
+struct ref_viewpass_s;
+
 typedef struct render_api_s
 {
 	// Get renderer info (doesn't changes engine state at all)
-	int		(*RenderGetParm)( int parm, int arg );	// generic
+	intptr_t	(*RenderGetParm)( int parm, int arg );	// generic
 	void		(*GetDetailScaleForTexture)( int texture, float *xScale, float *yScale );
 	void		(*GetExtraParmsForTexture)( int texture, byte *red, byte *green, byte *blue, byte *alpha );
 	lightstyle_t*	(*GetLightStyle)( int number );
@@ -175,9 +181,9 @@ typedef struct render_api_s
 	const char*	(*GL_TextureName)( unsigned int texnum );
 	const byte*	(*GL_TextureData)( unsigned int texnum ); // may be NULL
 	int		(*GL_LoadTexture)( const char *name, const byte *buf, size_t size, int flags );
-	int		(*GL_CreateTexture)( const char *name, int width, int height, const void *buffer, int flags ); 
+	int		(*GL_CreateTexture)( const char *name, int width, int height, const void *buffer, texFlags_t flags );
 	int		(*GL_LoadTextureArray)( const char **names, int flags );
-	int		(*GL_CreateTextureArray)( const char *name, int width, int height, int depth, const void *buffer, int flags );
+	int		(*GL_CreateTextureArray)( const char *name, int width, int height, int depth, const void *buffer, texFlags_t flags );
 	void		(*GL_FreeTexture)( unsigned int texnum );
 
 	// Decals manipulating (draw & remove)
@@ -187,9 +193,9 @@ typedef struct render_api_s
 
 	// AVIkit support
 	void		*(*AVI_LoadVideo)( const char *filename, qboolean load_audio );
-	int		(*AVI_GetVideoInfo)( void *Avi, long *xres, long *yres, float *duration );
+	int		(*AVI_GetVideoInfo)( void *Avi, int *xres, int *yres, float *duration ); // a1ba: changed longs to int
-	long		(*AVI_GetVideoFrameNumber)( void *Avi, float time );
+	int		(*AVI_GetVideoFrameNumber)( void *Avi, float time );
-	byte		*(*AVI_GetVideoFrame)( void *Avi, long frame );
+	byte		*(*AVI_GetVideoFrame)( void *Avi, int frame );
 	void		(*AVI_UploadRawFrame)( int texture, int cols, int rows, int width, int height, const byte *data );
 	void		(*AVI_FreeVideo)( void *Avi );
 	int		(*AVI_IsActive)( void *Avi );
@@ -219,7 +225,7 @@ typedef struct render_api_s
 	struct mstudiotex_s *( *StudioGetTexture )( struct cl_entity_s *e );
 	const struct ref_overview_s *( *GetOverviewParms )( void );
 	const char	*( *GetFileByIndex )( int fileindex );
-	int		(*pfnSaveFile)( const char *filename, const void *data, long len );
+	int		(*pfnSaveFile)( const char *filename, const void *data, int len );
 	void		(*R_Reserved0)( void );
 
 	// static allocations
@@ -228,14 +234,15 @@ typedef struct render_api_s
 
  	// engine utils (not related with render API but placed here)
 	char		**(*pfnGetFilesList)( const char *pattern, int *numFiles, int gamedironly );
-	unsigned long	(*pfnFileBufferCRC32)( const void *buffer, const int length );
+	unsigned int	(*pfnFileBufferCRC32)( const void *buffer, const int length );
 	int		(*COM_CompareFileTime)( const char *filename1, const char *filename2, int *iCompare );
 	void		(*Host_Error)( const char *error, ... ); // cause Host Error
 	void*		( *pfnGetModel )( int modelindex );
 	float		(*pfnTime)( void );				// Sys_DoubleTime
-	void		(*Cvar_Set)( char *name, char *value );
+	void		(*Cvar_Set)( const char *name, const char *value );
 	void		(*S_FadeMusicVolume)( float fadePercent );	// fade background track (0-100 percents)
-	void		(*SetRandomSeed)( long lSeed );		// set custom seed for RANDOM_FLOAT\RANDOM_LONG for predictable random
+	// a1ba: changed long to int
+	void		(*SetRandomSeed)( int lSeed );		// set custom seed for RANDOM_FLOAT\RANDOM_LONG for predictable random
 	// ONLY ADD NEW FUNCTIONS TO THE END OF THIS STRUCT.  INTERFACE VERSION IS FROZEN AT 37
 } render_api_t;
 

common/studio_event.h

@@ -12,16 +12,26 @@
 *   without written permission from Valve LLC.
 *
 ****/
-
+#pragma once
 #ifndef STUDIO_EVENT_H
 #define STUDIO_EVENT_H
 
+#define MAXEVENTSTRING		64
+
 typedef struct mstudioevent_s
 {
-	int 		frame;
+	// the frame at which this animation event occurs
-	int		event;
+	int32_t 	frame;
-	int		type;
+
-	char		options[64];
+	// the script event type
+	int32_t		event;
+
+	// was "type"
+	int32_t		unused;
+
+	// options
+	// could be path to sound WAVE files
+	char		options[MAXEVENTSTRING];
 } mstudioevent_t;
 
 #endif // STUDIO_EVENT_H

common/synctype.h

@@ -0,0 +1,24 @@
+/*
+synctype.h -- shared synctype_t definition
+Copyright (C) 1996-1997 Id Software, Inc.
+Copyright (C) 2023 Alibek Omarov
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public 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 SYNCTYPE_H
+#define SYNCTYPE_H
+typedef enum {ST_SYNC=0, ST_RAND } synctype_t;
+#endif

common/triangleapi.h

@@ -44,14 +44,14 @@ typedef struct triangleapi_s
 	void	(*Color4f)( float r, float g, float b, float a );
 	void	(*Color4ub)( unsigned char r, unsigned char g, unsigned char b, unsigned char a );
 	void	(*TexCoord2f)( float u, float v );
-	void	(*Vertex3fv)( float *worldPnt );
+	void	(*Vertex3fv)( const float *worldPnt );
 	void	(*Vertex3f)( float x, float y, float z );
 	void	(*Brightness)( float brightness );
 	void	(*CullFace)( TRICULLSTYLE style );
 	int	(*SpriteTexture)( struct model_s *pSpriteModel, int frame );
-	int	(*WorldToScreen)( float *world, float *screen );  // Returns 1 if it's z clipped
+	int	(*WorldToScreen)( const float *world, float *screen );  // Returns 1 if it's z clipped
 	void	(*Fog)( float flFogColor[3], float flStart, float flEnd, int bOn ); //Works just like GL_FOG, flFogColor is r/g/b.
-	void	(*ScreenToWorld)( float *screen, float *world  ); 
+	void	(*ScreenToWorld)( const float *screen, float *world  );
 	void	(*GetMatrix)( const int pname, float *matrix );
 	int	(*BoxInPVS)( float *mins, float *maxs );
 	void	(*LightAtPoint)( float *pos, float *value );

common/xash3d_types.h

@@ -0,0 +1,200 @@
+// basic typedefs
+#ifndef XASH_TYPES_H
+#define XASH_TYPES_H
+
+#include "build.h"
+
+#if XASH_IRIX
+#include <port.h>
+#endif
+
+#if XASH_WIN32
+#include <wchar.h> // off_t
+#endif // _WIN32
+
+#include <sys/types.h> // off_t
+#include STDINT_H
+#include <assert.h>
+
+typedef unsigned char byte;
+typedef int		sound_t;
+typedef float		vec_t;
+typedef vec_t		vec2_t[2];
+typedef vec_t		vec3_t[3];
+typedef vec_t		vec4_t[4];
+typedef vec_t		quat_t[4];
+typedef byte		rgba_t[4];	// unsigned byte colorpack
+typedef byte		rgb_t[3];		// unsigned byte colorpack
+typedef vec_t		matrix3x4[3][4];
+typedef vec_t		matrix4x4[4][4];
+
+#if XASH_64BIT
+typedef uint32_t        poolhandle_t;
+#else
+typedef void*           poolhandle_t;
+#endif
+
+#undef true
+#undef false
+
+#ifndef __cplusplus
+typedef enum { false, true }	qboolean;
+#else
+typedef int qboolean;
+#endif
+
+typedef uint64_t longtime_t;
+
+#define MAX_STRING		256	// generic string
+#define MAX_INFO_STRING	256	// infostrings are transmitted across network
+#define MAX_SERVERINFO_STRING	512	// server handles too many settings. expand to 1024?
+#define MAX_LOCALINFO_STRING	32768	// localinfo used on server and not sended to the clients
+#define MAX_SYSPATH		1024	// system filepath
+#define MAX_VA_STRING	1024	// string length returned by va()
+#define MAX_PRINT_MSG	8192	// how many symbols can handle single call of Con_Printf or Con_DPrintf
+#define MAX_TOKEN		2048	// parse token length
+#define MAX_MODS		512	// environment games that engine can keep visible
+#define MAX_USERMSG_LENGTH	2048	// don't modify it's relies on a client-side definitions
+
+#define BIT( n )		( 1U << ( n ))
+#define BIT64( n )		( 1ULL << ( n ))
+#define GAMMA		( 2.2f )		// Valve Software gamma
+#define INVGAMMA		( 1.0f / 2.2f )	// back to 1.0
+#define TEXGAMMA		( 0.9f )		// compensate dim textures
+#define SetBits( iBitVector, bits )	((iBitVector) = (iBitVector) | (bits))
+#define ClearBits( iBitVector, bits )	((iBitVector) = (iBitVector) & ~(bits))
+#define FBitSet( iBitVector, bit )	((iBitVector) & (bit))
+
+#ifndef __cplusplus
+#ifdef NULL
+#undef NULL
+#endif
+
+#define NULL		((void *)0)
+#endif
+
+// color strings
+#define IsColorString( p )	( p && *( p ) == '^' && *(( p ) + 1) && *(( p ) + 1) >= '0' && *(( p ) + 1 ) <= '9' )
+#define ColorIndex( c )	((( c ) - '0' ) & 7 )
+
+#if defined(__GNUC__)
+	#ifdef __i386__
+		#define EXPORT __attribute__ ((visibility ("default"),force_align_arg_pointer))
+		#define GAME_EXPORT __attribute((force_align_arg_pointer))
+	#else
+		#define EXPORT __attribute__ ((visibility ("default")))
+		#define GAME_EXPORT
+	#endif
+	#define _format(x) __attribute__((format(printf, x, x+1)))
+	#define NORETURN __attribute__((noreturn))
+	#define NONNULL __attribute__((nonnull))
+#elif defined(_MSC_VER)
+	#define EXPORT          __declspec( dllexport )
+	#define GAME_EXPORT
+	#define _format(x)
+	#define NORETURN
+	#define NONNULL
+#else
+	#define EXPORT
+	#define GAME_EXPORT
+	#define _format(x)
+	#define NORETURN
+	#define NONNULL
+#endif
+
+#if ( __GNUC__ >= 3 )
+	#define unlikely(x) __builtin_expect(x, 0)
+	#define likely(x)   __builtin_expect(x, 1)
+#elif defined( __has_builtin )
+	#if __has_builtin( __builtin_expect )
+		#define unlikely(x) __builtin_expect(x, 0)
+		#define likely(x)   __builtin_expect(x, 1)
+	#else
+		#define unlikely(x) (x)
+		#define likely(x)   (x)
+	#endif
+#else
+	#define unlikely(x) (x)
+	#define likely(x)   (x)
+#endif
+
+#if defined( static_assert ) // C11 static_assert
+#define STATIC_ASSERT static_assert
+#else
+#define STATIC_ASSERT( x, y ) extern int _static_assert_##__LINE__[( x ) ? 1 : -1]
+#endif
+
+#ifdef XASH_BIG_ENDIAN
+#define LittleLong(x) (((int)(((x)&255)<<24)) + ((int)((((x)>>8)&255)<<16)) + ((int)(((x)>>16)&255)<<8) + (((x) >> 24)&255))
+#define LittleLongSW(x) (x = LittleLong(x) )
+#define LittleShort(x) ((short)( (((short)(x) >> 8) & 255) + (((short)(x) & 255) << 8)))
+#define LittleShortSW(x) (x = LittleShort(x) )
+_inline float LittleFloat( float f )
+{
+	union
+	{
+		float f;
+		unsigned char 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;
+}
+#else
+#define LittleLong(x) (x)
+#define LittleLongSW(x)
+#define LittleShort(x) (x)
+#define LittleShortSW(x)
+#define LittleFloat(x) (x)
+#endif
+
+
+typedef unsigned int	dword;
+typedef unsigned int	uint;
+typedef char		string[MAX_STRING];
+typedef struct file_s	file_t;		// normal file
+typedef struct stream_s	stream_t;		// sound stream for background music playing
+typedef off_t fs_offset_t;
+#if XASH_WIN32
+typedef int fs_size_t; // return type of _read, _write funcs
+#else /* !XASH_WIN32 */
+typedef ssize_t fs_size_t;
+#endif /* !XASH_WIN32 */
+
+typedef struct dllfunc_s
+{
+	const char	*name;
+	void		**func;
+} dllfunc_t;
+
+typedef struct dll_info_s
+{
+	const char	*name;	// name of library
+	const dllfunc_t	*fcts;	// list of dll exports
+	qboolean		crash;	// crash if dll not found
+	void		*link;	// hinstance of loading library
+} dll_info_t;
+
+typedef void (*setpair_t)( const char *key, const void *value, const void *buffer, void *numpairs );
+typedef void *(*pfnCreateInterface_t)( const char *, int * );
+
+// config strings are a general means of communication from
+// the server to all connected clients.
+// each config string can be at most CS_SIZE characters.
+#if XASH_LOW_MEMORY == 0
+#define MAX_QPATH		64	// max length of a game pathname
+#elif XASH_LOW_MEMORY == 2
+#define MAX_QPATH		32 // should be enough for singleplayer
+#elif XASH_LOW_MEMORY == 1
+#define MAX_QPATH 48
+#endif
+#define MAX_OSPATH		260	// max length of a filesystem pathname
+#define CS_SIZE		64	// size of one config string
+#define CS_TIME		16	// size of time string
+
+#endif // XASH_TYPES_H

engine/alias.h

@@ -16,6 +16,10 @@
 #ifndef ALIAS_H
 #define ALIAS_H
 
+#include "build.h"
+#include STDINT_H
+#include "synctype.h"
+
 /*
 ==============================================================================
 
@@ -39,16 +43,6 @@ Alias models are position independent, so the cache manager can move them.
 #define ALIAS_TRACER2		0x0040	// orange split trail + rotate
 #define ALIAS_TRACER3		0x0080	// purple trail
 
-// must match definition in sprite.h
-#ifndef SYNCTYPE_T
-#define SYNCTYPE_T
-typedef enum
-{
-	ST_SYNC = 0,
-	ST_RAND
-} synctype_t;
-#endif
-
 typedef enum
 {
 	ALIAS_SINGLE = 0,
@@ -63,36 +57,42 @@ typedef enum
 
 typedef struct
 {
-	int		ident;
+	int32_t		ident;
-	int		version;
+	int32_t		version;
 	vec3_t		scale;
 	vec3_t		scale_origin;
 	float		boundingradius;
 	vec3_t		eyeposition;
-	int		numskins;
+	int32_t		numskins;
-	int		skinwidth;
+	int32_t		skinwidth;
-	int		skinheight;
+	int32_t		skinheight;
-	int		numverts;
+	int32_t		numverts;
-	int		numtris;
+	int32_t		numtris;
-	int		numframes;
+	int32_t		numframes;
-	synctype_t	synctype;
+	uint32_t	synctype; // was synctype_t
-	int		flags;
+	int32_t		flags;
 	float		size;
 } daliashdr_t;
 
+STATIC_ASSERT( sizeof( daliashdr_t ) == 84, "invalid daliashdr_t size" );
+
 typedef struct
 {
-	int		onseam;
+	int32_t		onseam;
-	int		s;
+	int32_t		s;
-	int		t;
+	int32_t		t;
 } stvert_t;
 
+STATIC_ASSERT( sizeof( stvert_t ) == 12, "invalid stvert_t size" );
+
 typedef struct dtriangle_s
 {
-	int		facesfront;
+	int32_t		facesfront;
-	int		vertindex[3];
+	int32_t		vertindex[3];
 } dtriangle_t;
 
+STATIC_ASSERT( sizeof( dtriangle_t ) == 16, "invalid dtriangle_t size" );
+
 #define DT_FACES_FRONT	0x0010
 #define ALIAS_ONSEAM	0x0020
 
@@ -103,36 +103,50 @@ typedef struct
 	char		name[16];	// frame name from grabbing
 } daliasframe_t;
 
+STATIC_ASSERT( sizeof( daliasframe_t ) == 24, "invalid daliasframe_t size" );
+
 typedef struct
 {
-	int		numframes;
+	int32_t		numframes;
 	trivertex_t	bboxmin;	// lightnormal isn't used
 	trivertex_t	bboxmax;	// lightnormal isn't used
 } daliasgroup_t;
 
+STATIC_ASSERT( sizeof( daliasgroup_t ) == 12, "invalid daliasgrou_t size" );
+
 typedef struct
 {
-	int		numskins;
+	int32_t		numskins;
 } daliasskingroup_t;
 
+STATIC_ASSERT( sizeof( daliasskingroup_t ) == 4, "invalid daliasskingroup_t size" );
+
 typedef struct
 {
 	float		interval;
 } daliasinterval_t;
 
+STATIC_ASSERT( sizeof( daliasinterval_t ) == 4, "invalid daliasinterval_t size" );
+
 typedef struct
 {
 	float		interval;
 } daliasskininterval_t;
 
+STATIC_ASSERT( sizeof( daliasskininterval_t ) == 4, "invalid daliasskininterval_t size" );
+
 typedef struct
 {
-	aliasframetype_t	type;
+	uint32_t	type; // was aliasframetype_t
 } daliasframetype_t;
 
+STATIC_ASSERT( sizeof( daliasframetype_t ) == 4, "invalid daliasframetype_t size" );
+
 typedef struct
 {
-	aliasskintype_t	type;
+	uint32_t	type; // was aliasskintype_t
 } daliasskintype_t;
 
+STATIC_ASSERT( sizeof( daliasskintype_t ) == 4, "invalid daliasskintype_t size" );
+
 #endif//ALIAS_H

engine/cdll_exp.h

@@ -15,6 +15,14 @@ GNU General Public License for more details.
 #ifndef CDLL_EXP_H
 #define CDLL_EXP_H
 
+struct tempent_s;
+struct usercmd_s;
+struct physent_s;
+struct playermove_s;
+struct mstudioevent_s;
+struct engine_studio_api_s;
+struct r_studio_interface_s;
+
 // NOTE: ordering is important!
 typedef struct cldll_func_s
 {
@@ -62,6 +70,10 @@ typedef struct cldll_func_s
 	// Xash3D extension
 	int	(*pfnGetRenderInterface)( int version, render_api_t *renderfuncs, render_interface_t *callback );
 	void	(*pfnClipMoveToEntity)( struct physent_s *pe, const vec3_t start, vec3_t mins, vec3_t maxs, const vec3_t end, struct pmtrace_s *tr );
+	// Xash3D FWGS extension
+	int (*pfnTouchEvent)( int type, int fingerID, float x, float y, float dx, float dy );
+	void (*pfnMoveEvent)( float forwardmove, float sidemove );
+	void (*pfnLookEvent)( float relyaw, float relpitch );
 } cldll_func_t;
 
 #endif//CDLL_EXP_H

engine/cdll_int.h

@@ -27,6 +27,16 @@ extern "C" {
 #endif
 
 #include "const.h"
+#include <stdint.h>
+
+#define MAX_ALIAS_NAME	32
+
+typedef struct cmdalias_s
+{
+	struct cmdalias_s	*next;
+	char		name[MAX_ALIAS_NAME];
+	char		*value;
+} cmdalias_t;
 
 // this file is included by both the engine and the client-dll,
 // so make sure engine declarations aren't done twice
@@ -96,8 +106,14 @@ typedef struct hud_player_info_s
 	char		*model;
 	short		topcolor;
 	short		bottomcolor;
+
+	uint64_t	m_nSteamID;
 } hud_player_info_t;
 
+struct screenfade_s;
+struct tagPOINT;
+struct event_args_s;
+
 typedef struct cl_enginefuncs_s
 {
 	// sprite handlers
@@ -119,20 +135,20 @@ typedef struct cl_enginefuncs_s
 	void	(*pfnSetCrosshair)( HSPRITE hspr, wrect_t rc, int r, int g, int b );
 
 	// cvar handlers
-	struct cvar_s *(*pfnRegisterVariable)( char *szName, char *szValue, int flags );
+	struct cvar_s *(*pfnRegisterVariable)( const char *szName, const char *szValue, int flags );
-	float	(*pfnGetCvarFloat)( char *szName );
+	float	(*pfnGetCvarFloat)( const char *szName );
-	char*	(*pfnGetCvarString)( char *szName );
+	const char*	(*pfnGetCvarString)( const char *szName );
 
 	// command handlers
-	int	(*pfnAddCommand)( char *cmd_name, void (*function)(void) );
+	int	(*pfnAddCommand)( const char *cmd_name, void (*function)(void) );
-	int	(*pfnHookUserMsg)( char *szMsgName, pfnUserMsgHook pfn );
+	int	(*pfnHookUserMsg)( const char *szMsgName, pfnUserMsgHook pfn );
-	int	(*pfnServerCmd)( char *szCmdString );
+	int	(*pfnServerCmd)( const char *szCmdString );
-	int	(*pfnClientCmd)( char *szCmdString );
+	int	(*pfnClientCmd)( const char *szCmdString );
 
 	void	(*pfnGetPlayerInfo)( int ent_num, hud_player_info_t *pinfo );
 
 	// sound handlers
-	void	(*pfnPlaySoundByName)( char *szSound, float volume );
+	void	(*pfnPlaySoundByName)( const char *szSound, float volume );
 	void	(*pfnPlaySoundByIndex)( int iSound, float volume );
 
 	// vector helpers
@@ -154,14 +170,14 @@ typedef struct cl_enginefuncs_s
 	void	(*GetViewAngles)( float * );
 	void	(*SetViewAngles)( float * );
 	int	(*GetMaxClients)( void );
-	void	(*Cvar_SetValue)( char *cvar, float value );
+	void	(*Cvar_SetValue)( const char *cvar, float value );
 
 	int   (*Cmd_Argc)( void );
-	char	*(*Cmd_Argv)( int arg );
+	const char	*(*Cmd_Argv)( int arg );
-	void	(*Con_Printf)( char *fmt, ... );
+	void	(*Con_Printf)( const char *fmt, ... );
-	void	(*Con_DPrintf)( char *fmt, ... );
+	void	(*Con_DPrintf)( const char *fmt, ... );
-	void	(*Con_NPrintf)( int pos, char *fmt, ... );
+	void	(*Con_NPrintf)( int pos, const char *fmt, ... );
-	void	(*Con_NXPrintf)( struct con_nprint_s *info, char *fmt, ... );
+	void	(*Con_NXPrintf)( struct con_nprint_s *info, const char *fmt, ... );
 
 	const char* (*PhysInfo_ValueForKey)( const char *key );
 	const char* (*ServerInfo_ValueForKey)( const char *key );
@@ -180,8 +196,8 @@ typedef struct cl_enginefuncs_s
 	void	(*V_CalcShake)( void );
 	void	(*V_ApplyShake)( float *origin, float *angles, float factor );
 
-	int	(*PM_PointContents)( float *point, int *truecontents );
+	int	(*PM_PointContents)( const float *point, int *truecontents );
-	int	(*PM_WaterEntity)( float *p );
+	int	(*PM_WaterEntity)( const float *p );
 	struct pmtrace_s *(*PM_TraceLine)( float *start, float *end, int flags, int usehull, int ignore_pe );
 
 	struct model_s *(*CL_LoadModel)( const char *modelname, int *index );
@@ -194,19 +210,20 @@ typedef struct cl_enginefuncs_s
 	void	(*pfnPlaybackEvent)( int flags, const struct edict_s *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 );
 	void	(*pfnWeaponAnim)( int iAnim, int body );
 	float	(*pfnRandomFloat)( float flLow, float flHigh );
-	long	(*pfnRandomLong)( long lLow, long lHigh );
+	int	(*pfnRandomLong)( int lLow, int lHigh );
-	void	(*pfnHookEvent)( char *name, void ( *pfnEvent )( struct event_args_s *args ));
+	void	(*pfnHookEvent)( const char *name, void ( *pfnEvent )( struct event_args_s *args ));
-	int	(*Con_IsVisible) ();
+
+	int	(*Con_IsVisible) ( void );
 	const char *(*pfnGetGameDirectory)( void );
 	struct cvar_s *(*pfnGetCvarPointer)( const char *szName );
 	const char *(*Key_LookupBinding)( const char *pBinding );
 	const char *(*pfnGetLevelName)( void );
 	void	(*pfnGetScreenFade)( struct screenfade_s *fade );
 	void	(*pfnSetScreenFade)( struct screenfade_s *fade );
-	void*	(*VGui_GetPanel)( );
+	void*	(*VGui_GetPanel)( void );
 	void	(*VGui_ViewportPaintBackground)( int extents[4] );
 
-	byte*	(*COM_LoadFile)( char *path, int usehunk, int *pLength );
+	byte*	(*COM_LoadFile)( const char *path, int usehunk, int *pLength );
 	char*	(*COM_ParseFile)( char *data, char *token );
 	void	(*COM_FreeFile)( void *buffer );
 
@@ -248,39 +265,47 @@ typedef struct cl_enginefuncs_s
 	void	(*pfnGetMousePos)( struct tagPOINT *ppt );
 	void	(*pfnSetMousePos)( int x, int y );
 	void	(*pfnSetMouseEnable)( qboolean fEnable );
-	void	(*pfnUnused1)( void );
+
-	void	(*pfnUnused2)( void );
+	// undocumented interface starts here
-	void	(*pfnUnused3)( void );
+	struct cvar_s*	(*pfnGetFirstCvarPtr)( void );
-	void	(*pfnUnused4)( void );
+	void*		(*pfnGetFirstCmdFunctionHandle)( void );
+	void*		(*pfnGetNextCmdFunctionHandle)( void *cmdhandle );
+	const char*	(*pfnGetCmdFunctionName)( void *cmdhandle );
 	float		(*pfnGetClientOldTime)( void );
 	float		(*pfnGetGravity)( void );
 	struct model_s*	(*pfnGetModelByIndex)( int index );
-	void	(*pfnUnused5)( void );
+	void		(*pfnSetFilterMode)( int mode ); // same as gl_texsort in original Quake
-	void	(*pfnUnused6)( void );
+	void		(*pfnSetFilterColor)( float red, float green, float blue );
-	void	(*pfnUnused7)( void );
+	void		(*pfnSetFilterBrightness)( float brightness );
-	void	(*pfnUnused8)( void );
+	void		*(*pfnSequenceGet)( const char *fileName, const char *entryName );
-	void	(*pfnUnused9)( void );
+	void		(*pfnSPR_DrawGeneric)( int frame, int x, int y, const wrect_t *prc, int blendsrc, int blenddst, int width, int height );
-	void	(*pfnUnused10)( void );
+	void		*(*pfnSequencePickSentence)( const char *groupName, int pickMethod, int *entryPicked );
-	void	(*pfnUnused11)( void );
+	int		(*pfnDrawString)( int x, int y, const char *str, int r, int g, int b );
-	void	(*pfnUnused12)( void );
+	int		(*pfnDrawStringReverse)( int x, int y, const char *str, int r, int g, int b );
 	const char	*(*LocalPlayerInfo_ValueForKey)( const char* key );
-	void	(*pfnUnused13)( void );
+	int		(*pfnVGUI2DrawCharacter)( int x, int y, int ch, unsigned int font );
-	void	(*pfnUnused14)( void );
+	int		(*pfnVGUI2DrawCharacterAdditive)( int x, int y, int ch, int r, int g, int b, unsigned int font );
-	void	(*pfnUnused15)( void );
+	unsigned int	(*pfnGetApproxWavePlayLen)( const char *filename );
-	void	(*pfnUnused16)( void );
+	void*		(*GetCareerGameUI)( void );	// g-cont. !!!! potential crash-point!
-	void	(*Cvar_Set)( char *name, char *value );
+	void		(*Cvar_Set)( const char *name, const char *value );
-	void	(*pfnUnused17)( void );
+	int		(*pfnIsPlayingCareerMatch)( void );
-	void	(*pfnUnused18)( void );
+	void		(*pfnPlaySoundVoiceByName)( char *szSound, float volume, int pitch );
-	void	(*pfnUnused19)( void );
+	void		(*pfnPrimeMusicStream)( char *filename, int looping );
 	double		(*pfnSys_FloatTime)( void );
-	void	(*pfnUnused20)( void );
+
-	void	(*pfnUnused21)( void );
+	// decay funcs
-	void	(*pfnUnused22)( void );
+	void		(*pfnProcessTutorMessageDecayBuffer)( int *buffer, int buflen );
-	void	(*pfnUnused23)( void );
+	void		(*pfnConstructTutorMessageDecayBuffer)( int *buffer, int buflen );
+	void		(*pfnResetTutorMessageDecayData)( void );
+
+	void		(*pfnPlaySoundByNameAtPitch)( char *szSound, float volume, int pitch );
 	void		(*pfnFillRGBABlend)( int x, int y, int width, int height, int r, int g, int b, int a );
 	int		(*pfnGetAppID)( void );
-	void	(*pfnUnused24)( void );
+	cmdalias_t	*(*pfnGetAliases)( void );
-	void	(*pfnUnused25)( void );
+	void		(*pfnVguiWrap2_GetMouseDelta)( int *x, int *y );
+
+	// added in 2019 update, not documented yet
+	int		(*pfnFilteredClientCmd)( const char *cmd );
 } cl_enginefunc_t;
 
 #define CLDLL_INTERFACE_VERSION	7

engine/client/avi/avi.h

@@ -0,0 +1,37 @@
+/*
+avi.h -- common avi support header
+Copyright (C) 2018 a1batross, Uncle Mike
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+*/
+#ifndef AVI_H
+#define AVI_H
+
+//
+// avikit.c
+//
+typedef struct movie_state_s  movie_state_t;
+int AVI_GetVideoFrameNumber( movie_state_t *Avi, float time );
+byte *AVI_GetVideoFrame( movie_state_t *Avi, int frame );
+qboolean AVI_GetVideoInfo( movie_state_t *Avi, int *xres, int *yres, float *duration );
+qboolean AVI_GetAudioInfo( movie_state_t *Avi, wavdata_t *snd_info );
+int AVI_GetAudioChunk( movie_state_t *Avi, char *audiodata, int offset, int length );
+void AVI_OpenVideo( movie_state_t *Avi, const char *filename, qboolean load_audio, int quiet );
+movie_state_t *AVI_LoadVideo( const char *filename, qboolean load_audio );
+int AVI_TimeToSoundPosition( movie_state_t *Avi, int time );
+void AVI_CloseVideo( movie_state_t *Avi );
+qboolean AVI_IsActive( movie_state_t *Avi );
+void AVI_FreeVideo( movie_state_t *Avi );
+movie_state_t *AVI_GetState( int num );
+qboolean AVI_Initailize( void );
+void AVI_Shutdown( void );
+
+#endif // AVI_H

engine/client/avi/avi_stub.c

@@ -0,0 +1,90 @@
+/*
+avi_stub.c - playing AVI files (stub)
+Copyright (C) 2018 a1batross
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+*/
+
+#include "build.h"
+#if !XASH_WIN32
+#include "common.h"
+
+int AVI_GetVideoFrameNumber( movie_state_t *Avi, float time )
+{
+	return 0;
+}
+
+byte *AVI_GetVideoFrame( movie_state_t *Avi, int frame )
+{
+	return NULL;
+}
+
+qboolean AVI_GetVideoInfo( movie_state_t *Avi, int *xres, int *yres, float *duration )
+{
+	return false;
+}
+
+qboolean AVI_GetAudioInfo( movie_state_t *Avi, wavdata_t *snd_info )
+{
+	return false;
+}
+
+int AVI_GetAudioChunk( movie_state_t *Avi, char *audiodata, int offset, int length )
+{
+	return 0;
+}
+
+void AVI_OpenVideo( movie_state_t *Avi, const char *filename, qboolean load_audio, int quiet )
+{
+	;
+}
+
+movie_state_t *AVI_LoadVideo( const char *filename, qboolean load_audio )
+{
+	return NULL;
+}
+
+int AVI_TimeToSoundPosition( movie_state_t *Avi, int time )
+{
+	return 0;
+}
+
+void AVI_CloseVideo( movie_state_t *Avi )
+{
+	;
+}
+
+qboolean AVI_IsActive( movie_state_t *Avi )
+{
+	return false;
+}
+
+void AVI_FreeVideo( movie_state_t *Avi )
+{
+	;
+}
+
+movie_state_t *AVI_GetState( int num )
+{
+	return NULL;
+}
+
+qboolean AVI_Initailize( void )
+{
+	return false;
+}
+
+void AVI_Shutdown( void )
+{
+	;
+}
+
+#endif // WIN32

engine/client/avi/avi_win.c

@@ -1,5 +1,6 @@
 /*
-avikit.c - playing AVI files (based on original AVIKit code)
+avi_win.c - playing AVI files (based on original AVIKit code, Win32 version)
+Copyright (c) 2003-2004, Ruari O'Sullivan
 Copyright (C) 2010 Uncle Mike
 
 This program is free software: you can redistribute it and/or modify
@@ -13,9 +14,10 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 */
 
+#include "build.h"
+#if XASH_WIN32
 #include "common.h"
 #include "client.h"
-#include "gl_local.h"
 #include <vfw.h> // video for windows
 
 // msvfw32.dll exports
@@ -58,14 +60,14 @@ dll_info_t msacm_dll = { "msacm32.dll", msacm_funcs, false };
 static int (_stdcall *pAVIStreamInfo)( PAVISTREAM pavi, AVISTREAMINFO *psi, LONG lSize );
 static int (_stdcall *pAVIStreamRead)( PAVISTREAM pavi, LONG lStart, LONG lSamples, void *lpBuffer, LONG cbBuffer, LONG *plBytes, LONG *plSamples );
 static PGETFRAME (_stdcall *pAVIStreamGetFrameOpen)( PAVISTREAM pavi, LPBITMAPINFOHEADER lpbiWanted );
-static long (_stdcall *pAVIStreamTimeToSample)( PAVISTREAM pavi, LONG lTime );
+static int (_stdcall *pAVIStreamTimeToSample)( PAVISTREAM pavi, LONG lTime );
 static void* (_stdcall *pAVIStreamGetFrame)( PGETFRAME pg, LONG lPos );
 static int (_stdcall *pAVIStreamGetFrameClose)( PGETFRAME pg );
 static dword (_stdcall *pAVIStreamRelease)( PAVISTREAM pavi );
-static int (_stdcall *pAVIFileOpen)( PAVIFILE *ppfile, LPCSTR szFile, UINT uMode, LPCLSID lpHandler );
+static int (_stdcall *pAVIFileOpenW)( PAVIFILE *ppfile, LPCWSTR szFile, UINT uMode, LPCLSID lpHandler );
 static int (_stdcall *pAVIFileGetStream)( PAVIFILE pfile, PAVISTREAM *ppavi, DWORD fccType, LONG lParam );
 static int (_stdcall *pAVIStreamReadFormat)( PAVISTREAM pavi, LONG lPos,LPVOID lpFormat, LONG *lpcbFormat );
-static long (_stdcall *pAVIStreamStart)( PAVISTREAM pavi );
+static int (_stdcall *pAVIStreamStart)( PAVISTREAM pavi );
 static dword (_stdcall *pAVIFileRelease)( PAVIFILE pfile );
 static void (_stdcall *pAVIFileInit)( void );
 static void (_stdcall *pAVIFileExit)( void );
@@ -75,7 +77,7 @@ static dllfunc_t avifile_funcs[] =
 { "AVIFileExit", (void **) &pAVIFileExit },
 { "AVIFileGetStream", (void **) &pAVIFileGetStream },
 { "AVIFileInit", (void **) &pAVIFileInit },
-{ "AVIFileOpenA", (void **) &pAVIFileOpen },
+{ "AVIFileOpenW", (void **) &pAVIFileOpenW },
 { "AVIFileRelease", (void **) &pAVIFileRelease },
 { "AVIStreamGetFrame", (void **) &pAVIStreamGetFrame },
 { "AVIStreamGetFrameClose", (void **) &pAVIStreamGetFrameClose },
@@ -99,17 +101,17 @@ typedef struct movie_state_s
 	PAVIFILE		pfile;		// avi file pointer
 	PAVISTREAM	video_stream;	// video stream pointer
 	PGETFRAME		video_getframe;	// pointer to getframe object for video stream
-	long		video_frames;	// total frames
+	int		video_frames;	// total frames
-	long		video_xres;	// video stream resolution
+	int		video_xres;	// video stream resolution
-	long		video_yres;
+	int		video_yres;
 	float		video_fps;	// video stream fps
 
 	PAVISTREAM	audio_stream;	// audio stream pointer
 	WAVEFORMAT	*audio_header;	// audio stream header
-	long		audio_header_size;	// WAVEFORMAT is returned for PCM data; WAVEFORMATEX for others
+	int		audio_header_size;	// WAVEFORMAT is returned for PCM data; WAVEFORMATEX for others
-	long		audio_codec;	// WAVE_FORMAT_PCM is oldstyle: anything else needs conversion
+	int		audio_codec;	// WAVE_FORMAT_PCM is oldstyle: anything else needs conversion
-	long		audio_length;	// in converted samples
+	int		audio_length;	// in converted samples
-	long		audio_bytes_per_sample; // guess.
+	int		audio_bytes_per_sample; // guess.
 
 	// compressed audio specific data
 	dword		cpa_blockalign;	// block size to read
@@ -251,7 +253,7 @@ qboolean AVI_ACMConvertAudio( movie_state_t *Avi )
 	return true;
 }
 
-qboolean AVI_GetVideoInfo( movie_state_t *Avi, long *xres, long *yres, float *duration )
+qboolean AVI_GetVideoInfo( movie_state_t *Avi, int *xres, int *yres, float *duration )
 {
 	if( !Avi->active )
 		return false;
@@ -269,7 +271,7 @@ qboolean AVI_GetVideoInfo( movie_state_t *Avi, long *xres, long *yres, float *du
 }
 
 // returns a unique frame identifier
-long AVI_GetVideoFrameNumber( movie_state_t *Avi, float time )
+int AVI_GetVideoFrameNumber( movie_state_t *Avi, float time )
 {
 	if( !Avi->active )
 		return 0;
@@ -277,15 +279,7 @@ long AVI_GetVideoFrameNumber( movie_state_t *Avi, float time )
 	return (time * Avi->video_fps);
 }
 
-long AVI_GetVideoFrameCount( movie_state_t *Avi )
+int AVI_TimeToSoundPosition( movie_state_t *Avi, int time )
-{
-	if( !Avi->active )
-		return 0;
-
-	return Avi->video_frames;
-}
-
-long AVI_TimeToSoundPosition( movie_state_t *Avi, long time )
 {
 	if( !Avi->active || !Avi->audio_stream )
 		return 0;
@@ -295,7 +289,7 @@ long AVI_TimeToSoundPosition( movie_state_t *Avi, long time )
 }
 
 // gets the raw frame data
-byte *AVI_GetVideoFrame( movie_state_t *Avi, long frame )
+byte *AVI_GetVideoFrame( movie_state_t *Avi, int frame )
 {
 	LPBITMAPINFOHEADER	frame_info;
 	byte		*frame_raw;
@@ -382,9 +376,9 @@ qboolean AVI_SeekPosition( movie_state_t *Avi, dword offset )
 }
 
 // get a chunk of audio from the stream (in bytes)
-long AVI_GetAudioChunk( movie_state_t *Avi, char *audiodata, long offset, long length )
+int AVI_GetAudioChunk( movie_state_t *Avi, char *audiodata, int offset, int length )
 {
-	long	result = 0;
+	int	result = 0;
 	int	i;
 
 	// zero data past the end of the file
@@ -392,7 +386,7 @@ long AVI_GetAudioChunk( movie_state_t *Avi, char *audiodata, long offset, long l
 	{
 		if( offset <= Avi->audio_length )
 		{
-			long	remaining_length = Avi->audio_length - offset;
+			int	remaining_length = Avi->audio_length - offset;
 
 			AVI_GetAudioChunk( Avi, audiodata, offset, remaining_length );
 
@@ -427,7 +421,7 @@ long AVI_GetAudioChunk( movie_state_t *Avi, char *audiodata, long offset, long l
 
 		while( length > 0 )
 		{
-			long	blockread = Avi->cpa_conversion_header.cbDstLengthUsed - Avi->cpa_blockpos;
+			int	blockread = Avi->cpa_conversion_header.cbDstLengthUsed - Avi->cpa_blockpos;
 
 			if( blockread <= 0 ) // read next
 			{
@@ -490,8 +484,9 @@ void AVI_OpenVideo( movie_state_t *Avi, const char *filename, qboolean load_audi
 {
 	BITMAPINFOHEADER	bmih;
 	AVISTREAMINFO	stream_info;
-	long		opened_streams = 0;
+	int		opened_streams = 0;
 	LONG		hr;
+	wchar_t		pathBuffer[MAX_PATH];
 
 	// default state: non-working.
 	Avi->active = false;
@@ -500,8 +495,15 @@ void AVI_OpenVideo( movie_state_t *Avi, const char *filename, qboolean load_audi
 	// can't load Video For Windows :-(
 	if( !avi_initialized ) return;
 
+	// convert to wide char
+	if( MultiByteToWideChar( CP_UTF8, 0, filename, -1, pathBuffer, ARRAYSIZE( pathBuffer )) <= 0 )
+	{
+		Con_DPrintf( S_ERROR "filename buffer limit exceeded\n" );
+		return;
+	}
+
 	// load the AVI
-	hr = pAVIFileOpen( &Avi->pfile, filename, OF_SHARE_DENY_WRITE, 0L );
+	hr = pAVIFileOpenW( &Avi->pfile, pathBuffer, OF_SHARE_DENY_WRITE, 0L );
 
 	if( hr != 0 ) // error opening AVI:
 	{
@@ -557,7 +559,7 @@ void AVI_OpenVideo( movie_state_t *Avi, const char *filename, qboolean load_audi
 		}
 		else if( stream_info.fccType == streamtypeAUDIO && Avi->audio_stream == NULL && load_audio )
 		{
-			long	size;
+			int	size;
 
 			Avi->audio_stream = stream;
 
@@ -570,7 +572,7 @@ void AVI_OpenVideo( movie_state_t *Avi, const char *filename, qboolean load_audi
 			Avi->audio_codec = Avi->audio_header->wFormatTag;
 
 			// length of converted audio in samples
-			Avi->audio_length = (long)((float)stream_info.dwLength / Avi->audio_header->nAvgBytesPerSec );
+			Avi->audio_length = (int)((float)stream_info.dwLength / Avi->audio_header->nAvgBytesPerSec );
 			Avi->audio_length *= Avi->audio_header->nSamplesPerSec;
 
 			if( Avi->audio_codec != WAVE_FORMAT_PCM )
@@ -656,7 +658,7 @@ movie_state_t *AVI_LoadVideo( const char *filename, qboolean load_audio )
 
 	// open cinematic
 	Q_snprintf( path, sizeof( path ), "media/%s", filename );
-	COM_DefaultExtension( path, ".avi" );
+	COM_DefaultExtension( path, ".avi", sizeof( path ));
 	fullpath = FS_GetDiskPath( path, false );
 
 	if( FS_FileExists( path, false ) && !fullpath )
@@ -730,3 +732,4 @@ void AVI_Shutdown( void )
 	Sys_FreeLibrary( &msacm_dll );
 	avi_initialized = false;
 }
+#endif // _WIN32

engine/client/cl_cmds.c

@@ -15,7 +15,6 @@ GNU General Public License for more details.
 
 #include "common.h"
 #include "client.h"
-#include "gl_local.h"
 
 /*
 ====================
@@ -86,6 +85,12 @@ void CL_PlayCDTrack_f( void )
 		paused = false;
 		looped = false;
 	}
+	else if( !Q_stricmp( command, "playfile" ))
+	{
+		S_StartBackgroundTrack( pszTrack, NULL, 0, true );
+		paused = false;
+		looped = false;
+	}
 	else if( !Q_stricmp( command, "loop" ))
 	{
 		if( Q_isdigit( pszTrack ))
@@ -97,6 +102,12 @@ void CL_PlayCDTrack_f( void )
 		paused = false;
 		looped = true;
 	}
+	else if( !Q_stricmp( command, "loopfile" ))
+	{
+		S_StartBackgroundTrack( pszTrack, pszTrack, 0, true );
+		paused = false;
+		looped = true;
+	}
 	else if( !Q_stricmp( command, "pause" ))
 	{
 		S_StreamSetPause( true );
@@ -127,7 +138,7 @@ void CL_PlayCDTrack_f( void )
 		int	i, maxTrack;
 
 		for( maxTrack = i = 0; i < MAX_CDTRACKS; i++ )
-			if( Q_strlen( clgame.cdtracks[i] )) maxTrack++;
+			if( COM_CheckStringEmpty( clgame.cdtracks[i] ) ) maxTrack++;
 
 		Con_Printf( "%u tracks\n", maxTrack );
 		if( track )
@@ -146,27 +157,15 @@ void CL_PlayCDTrack_f( void )
 CL_ScreenshotGetName
 ==================
 */
-qboolean CL_ScreenshotGetName( int lastnum, char *filename )
+static qboolean CL_ScreenshotGetName( int lastnum, char *filename, size_t size )
 {
-	int	a, b, c, d;
-
 	if( lastnum < 0 || lastnum > 9999 )
 	{
 		Con_Printf( S_ERROR "unable to write screenshot\n" );
 		return false;
 	}
 
-	a = lastnum / 1000;
+	return Q_snprintf( filename, size, "scrshots/%s_shot%04d.png", clgame.mapname, lastnum ) > 0;
-	lastnum -= a * 1000;
-	b = lastnum / 100;
-	lastnum -= b * 100;
-	c = lastnum / 10;
-	lastnum -= c * 10;
-	d = lastnum;
-
-	Q_sprintf( filename, "scrshots/%s_shot%i%i%i%i.bmp", clgame.mapname, a, b, c, d );
-
-	return true;
 }
 
 /*
@@ -174,10 +173,8 @@ qboolean CL_ScreenshotGetName( int lastnum, char *filename )
 CL_SnapshotGetName
 ==================
 */
-qboolean CL_SnapshotGetName( int lastnum, char *filename )
+static qboolean CL_SnapshotGetName( int lastnum, char *filename, size_t size )
 {
-	int	a, b, c, d;
-
 	if( lastnum < 0 || lastnum > 9999 )
 	{
 		Con_Printf( S_ERROR "unable to write snapshot\n" );
@@ -185,17 +182,7 @@ qboolean CL_SnapshotGetName( int lastnum, char *filename )
 		return false;
 	}
 
-	a = lastnum / 1000;
+	return Q_snprintf( filename, size, "../%s_%04d.png", clgame.mapname, lastnum ) > 0;
-	lastnum -= a * 1000;
-	b = lastnum / 100;
-	lastnum -= b * 100;
-	c = lastnum / 10;
-	lastnum -= c * 10;
-	d = lastnum;
-
-	Q_sprintf( filename, "../%s_%i%i%i%i.bmp", clgame.mapname, a, b, c, d );
-
-	return true;
 }
 
 /*
@@ -228,10 +215,10 @@ void CL_ScreenShot_f( void )
 		// scan for a free filename
 		for( i = 0; i < 9999; i++ )
 		{
-			if( !CL_ScreenshotGetName( i, checkname ))
+			if( !CL_ScreenshotGetName( i, checkname, sizeof( checkname )))
 				return;	// no namespace
 
-			if( !FS_FileExists( checkname, false ))
+			if( !FS_FileExists( checkname, true ))
 				break;
 		}
 
@@ -268,10 +255,10 @@ void CL_SnapShot_f( void )
 		// scan for a free filename
 		for( i = 0; i < 9999; i++ )
 		{
-			if( !CL_SnapshotGetName( i, checkname ))
+			if( !CL_SnapshotGetName( i, checkname, sizeof( checkname )))
 				return;	// no namespace
 
-			if( !FS_FileExists( checkname, false ))
+			if( !FS_FileExists( checkname, true ))
 				break;
 		}
 
@@ -299,7 +286,7 @@ void CL_EnvShot_f( void )
 		return;
 	}
 
-	Q_sprintf( cls.shotname, "gfx/env/%s", Cmd_Argv( 1 ));
+	Q_snprintf( cls.shotname, sizeof( cls.shotname ), "gfx/env/%s", Cmd_Argv( 1 ));
 	cls.scrshot_action = scrshot_envshot;	// build new frame for envshot
 	cls.envshot_vieworg = NULL; // no custom view
 	cls.envshot_viewsize = 0;
@@ -320,7 +307,7 @@ void CL_SkyShot_f( void )
 		return;
 	}
 
-	Q_sprintf( cls.shotname, "gfx/env/%s", Cmd_Argv( 1 ));
+	Q_snprintf( cls.shotname, sizeof( cls.shotname ),"gfx/env/%s", Cmd_Argv( 1 ));
 	cls.scrshot_action = scrshot_skyshot;	// build new frame for skyshot
 	cls.envshot_vieworg = NULL; // no custom view
 	cls.envshot_viewsize = 0;
@@ -344,7 +331,8 @@ void CL_LevelShot_f( void )
 	// check for exist
 	if( cls.demoplayback && ( cls.demonum != -1 ))
 	{
-		Q_sprintf( cls.shotname, "levelshots/%s_%s.bmp", cls.demoname, glState.wideScreen ? "16x9" : "4x3" );
+		Q_snprintf( cls.shotname, sizeof( cls.shotname ),
+			"levelshots/%s_%s.bmp", cls.demoname, refState.wideScreen ? "16x9" : "4x3" );
 		Q_snprintf( filename, sizeof( filename ), "%s.dem", cls.demoname );
 
 		// make sure what levelshot is newer than demo
@@ -353,7 +341,8 @@ void CL_LevelShot_f( void )
 	}
 	else
 	{
-		Q_sprintf( cls.shotname, "levelshots/%s_%s.bmp", clgame.mapname, glState.wideScreen ? "16x9" : "4x3" );
+		Q_snprintf( cls.shotname, sizeof( cls.shotname ),
+			"levelshots/%s_%s.bmp", clgame.mapname, refState.wideScreen ? "16x9" : "4x3" );
 
 		// make sure what levelshot is newer than bsp
 		ft1 = FS_FileTime( cl.worldmodel->name, false );
@@ -381,7 +370,7 @@ void CL_SaveShot_f( void )
 		return;
 	}
 
-	Q_sprintf( cls.shotname, "%s%s.bmp", DEFAULT_SAVE_DIRECTORY, Cmd_Argv( 1 ));
+	Q_snprintf( cls.shotname, sizeof( cls.shotname ), DEFAULT_SAVE_DIRECTORY "%s.bmp", Cmd_Argv( 1 ));
 	cls.scrshot_action = scrshot_savegame;	// build new frame for saveshot
 }
 
@@ -424,53 +413,7 @@ void CL_SetSky_f( void )
 		return;
 	}
 
-	R_SetupSky( Cmd_Argv( 1 ));
+	ref.dllFuncs.R_SetupSky( Cmd_Argv( 1 ));
-}
-
-/*
-================
-SCR_TimeRefresh_f
-
-timerefresh [noflip]
-================
-*/
-void SCR_TimeRefresh_f( void )
-{
-	int	i;
-	double	start, stop;
-	double	time;
-
-	if( cls.state != ca_active )
-		return;
-
-	start = Sys_DoubleTime();
-
-	// run without page flipping like GoldSrc
-	if( Cmd_Argc() == 1 )
-	{	
-		pglDrawBuffer( GL_FRONT );
-		for( i = 0; i < 128; i++ )
-		{
-			RI.viewangles[1] = i / 128.0 * 360.0f;
-			R_RenderScene();
-		}
-		pglFinish();
-		R_EndFrame();
-	}
-	else
-	{
-		for( i = 0; i < 128; i++ )
-		{
-			R_BeginFrame( true );
-			RI.viewangles[1] = i / 128.0 * 360.0f;
-			R_RenderScene();
-			R_EndFrame();
-		}
-	}
-
-	stop = Sys_DoubleTime ();
-	time = (stop - start);
-	Con_Printf( "%f seconds (%f fps)\n", time, 128 / time );
 }
 
 /*
@@ -482,6 +425,35 @@ viewpos (level-designer helper)
 */
 void SCR_Viewpos_f( void )
 {
-	Con_Printf( "org ( %g %g %g )\n", RI.vieworg[0], RI.vieworg[1], RI.vieworg[2] );
+	Con_Printf( "org ( %g %g %g )\n", refState.vieworg[0], refState.vieworg[1], refState.vieworg[2] );
-	Con_Printf( "ang ( %g %g %g )\n", RI.viewangles[0], RI.viewangles[1], RI.viewangles[2] );
+	Con_Printf( "ang ( %g %g %g )\n", refState.viewangles[0], refState.viewangles[1], refState.viewangles[2] );
+}
+
+/*
+=============
+CL_WavePlayLen_f
+
+=============
+*/
+void CL_WavePlayLen_f( void )
+{
+	const char *name;
+	uint msecs;
+
+	if( Cmd_Argc() != 2 )
+	{
+		Con_Printf( "waveplaylen <wave file name>: returns approximate number of milliseconds a wave file will take to play.\n" );
+		return;
+	}
+
+	name = Cmd_Argv( 1 );
+	msecs = Sound_GetApproxWavePlayLen( name );
+
+	if( msecs == 0 )
+	{
+		Con_Printf( "Unable to read %s, file may be missing or incorrectly formatted.\n", name );
+		return;
+	}
+
+	Con_Printf( "Play time is approximately %dms\n", msecs );
 }

engine/client/cl_custom.c

@@ -39,7 +39,7 @@ qboolean CL_CheckFile( sizebuf_t *msg, resource_t *pResource )
 	}
 
 	if( pResource->type == t_sound )
-		Q_strncpy( filepath, va( "%s%s", DEFAULT_SOUNDPATH, pResource->szFileName ), sizeof( filepath ));
+		Q_snprintf( filepath, sizeof( filepath ), DEFAULT_SOUNDPATH "%s", pResource->szFileName );
 	else Q_strncpy( filepath, pResource->szFileName, sizeof( filepath ));
 
 	if( !COM_IsSafeFileToDownload( filepath ))
@@ -70,8 +70,15 @@ qboolean CL_CheckFile( sizebuf_t *msg, resource_t *pResource )
 		return true;
 	}
 
+	if( cl.downloadUrl[0] )
+	{
+		HTTP_AddDownload( filepath, pResource->nDownloadSize, true );
+		host.downloadcount++;
+		return false;
+	}
+
 	MSG_BeginClientCmd( msg, clc_stringcmd );
-	MSG_WriteString( msg, va( "dlfile %s", filepath ));
+	MSG_WriteStringf( msg, "dlfile %s", filepath );
 	host.downloadcount++;
 
 	return false;

engine/client/cl_debug.c

@@ -17,7 +17,6 @@ GNU General Public License for more details.
 #include "client.h"
 #include "net_encode.h"
 #include "particledef.h"
-#include "gl_local.h"
 #include "cl_tent.h"
 #include "shake.h"
 #include "hltv.h"
@@ -26,69 +25,6 @@ GNU General Public License for more details.
 #define MSG_COUNT		32		// last 32 messages parsed
 #define MSG_MASK		(MSG_COUNT - 1)
 
-const char *svc_strings[svc_lastmsg+1] =
-{
-	"svc_bad",
-	"svc_nop",
-	"svc_disconnect",
-	"svc_event",
-	"svc_changing",
-	"svc_setview",
-	"svc_sound",
-	"svc_time",
-	"svc_print",
-	"svc_stufftext",
-	"svc_setangle",
-	"svc_serverdata",
-	"svc_lightstyle",
-	"svc_updateuserinfo",
-	"svc_deltatable",
-	"svc_clientdata",
-	"svc_resource",
-	"svc_pings",
-	"svc_particle",
-	"svc_restoresound",
-	"svc_spawnstatic",
-	"svc_event_reliable",
-	"svc_spawnbaseline",
-	"svc_temp_entity",
-	"svc_setpause",
-	"svc_signonnum",
-	"svc_centerprint",
-	"svc_unused27",
-	"svc_unused28",
-	"svc_unused29",
-	"svc_intermission",
-	"svc_finale",
-	"svc_cdtrack",
-	"svc_restore",
-	"svc_cutscene",
-	"svc_weaponanim",
-	"svc_bspdecal",
-	"svc_roomtype",
-	"svc_addangle",
-	"svc_usermessage",
-	"svc_packetentities",
-	"svc_deltapacketentities",
-	"svc_choke",
-	"svc_resourcelist",
-	"svc_deltamovevars",
-	"svc_resourcerequest",
-	"svc_customization",
-	"svc_crosshairangle",
-	"svc_soundfade",
-	"svc_filetxferfailed",
-	"svc_hltv",
-	"svc_director",
-	"svc_voiceinit",
-	"svc_voicedata",
-	"svc_deltapacketbones",
-	"svc_unused55",
-	"svc_resourcelocation",
-	"svc_querycvarvalue",
-	"svc_querycvarvalue2",
-};
-
 typedef struct
 {
 	int	command;
@@ -109,7 +45,7 @@ const char *CL_MsgInfo( int cmd )
 {
 	static string	sz;
 
-	Q_strcpy( sz, "???" );
+	Q_strncpy( sz, "???", sizeof( sz ));
 
 	if( cmd >= 0 && cmd <= svc_lastmsg )
 	{

engine/client/cl_demo.c

@@ -15,7 +15,6 @@ GNU General Public License for more details.
 
 #include "common.h"
 #include "client.h"
-#include "gl_local.h"
 #include "net_encode.h"
 
 #define dem_unknown		0	// unknown command
@@ -52,6 +51,7 @@ const char *demo_cmd[dem_lastcmd+1] =
 	"dem_stop",
 };
 
+#pragma pack( push, 1 )
 typedef struct
 {
 	int		id;		// should be IDEM
@@ -63,6 +63,7 @@ typedef struct
 	char		gamedir[64];	// name of game directory (FS_Gamedir())
 	int		directory_offset;	// offset of Entry Directory.
 } demoheader_t;
+#pragma pack( pop )
 
 typedef struct
 {
@@ -349,9 +350,9 @@ Write demo header
 */
 void CL_WriteDemoHeader( const char *name )
 {
-	long	copysize;
+	int	copysize;
-	long	savepos;
+	int	savepos;
-	long	curpos;
+	int	curpos;
 
 	Con_Printf( "recording to %s.\n", name );
 	cls.demofile = FS_Open( name, "wb", false );
@@ -370,8 +371,8 @@ void CL_WriteDemoHeader( const char *name )
 
 	demo.header.id = IDEMOHEADER;
 	demo.header.dem_protocol = DEMO_PROTOCOL;
-	demo.header.net_protocol = PROTOCOL_VERSION;
+	demo.header.net_protocol = cls.legacymode ? PROTOCOL_LEGACY_VERSION : PROTOCOL_VERSION;
-	demo.header.host_fps = bound( MIN_FPS, host_maxfps->value, MAX_FPS );
+	demo.header.host_fps = bound( MIN_FPS, host_maxfps.value, MAX_FPS );
 	Q_strncpy( demo.header.mapname, clgame.mapname, sizeof( demo.header.mapname ));
 	Q_strncpy( demo.header.comment, clgame.maptitle, sizeof( demo.header.comment ));
 	Q_strncpy( demo.header.gamedir, FS_Gamedir(), sizeof( demo.header.gamedir ));
@@ -489,7 +490,7 @@ void CL_DrawDemoRecording( void )
 {
 	char	string[64];
 	rgba_t	color = { 255, 255, 255, 255 };
-	long	pos;
+	int	pos;
 	int	len;
 
 	if(!( host_developer.value && cls.demorecording ))
@@ -500,7 +501,7 @@ void CL_DrawDemoRecording( void )
 		Q_memprint( pos ), (int)(cls.demotime / 60.0f ), (int)fmod( cls.demotime, 60.0f ));
 
 	Con_DrawStringLen( string, &len, NULL );
-	Con_DrawString(( glState.width - len ) >> 1, glState.height >> 2, string, color );
+	Con_DrawString(( refState.width - len ) >> 1, refState.height >> 4, string, color );
 }
 
 /*
@@ -517,14 +518,26 @@ CL_ReadDemoCmdHeader
 read the demo command
 =================
 */
-void CL_ReadDemoCmdHeader( byte *cmd, float *dt )
+qboolean CL_ReadDemoCmdHeader( byte *cmd, float *dt )
 {
 	// read the command
+	// HACKHACK: skip NOPs
+	do
+	{
 		FS_Read( cls.demofile, cmd, sizeof( byte ));
-	Assert( *cmd >= 1 && *cmd <= dem_lastcmd );
+	} while( *cmd == dem_unknown );
+
+	if( *cmd > dem_lastcmd )
+	{
+		Con_Printf( S_ERROR "Demo cmd %d > %d, file offset = %d\n", *cmd, dem_lastcmd, (int)FS_Tell( cls.demofile ));
+		CL_DemoCompleted();
+		return false;
+	}
 
 	// read the timestamp
 	FS_Read( cls.demofile, dt, sizeof( float ));
+
+	return true;
 }
 
 /*
@@ -635,11 +648,13 @@ void CL_DemoStartPlayback( int mode )
 {
 	if( cls.changedemo )
 	{
+		int maxclients = cl.maxclients;
+
 		S_StopAllSounds( true );
 		SCR_BeginLoadingPlaque( false );
 
 		CL_ClearState( );
-		CL_InitEdicts (); // re-arrange edicts
+		CL_InitEdicts( maxclients ); // re-arrange edicts
 	}
 	else
 	{
@@ -685,7 +700,7 @@ void CL_DemoAborted( void )
 	cls.demofile = NULL;
 	cls.demonum = -1;
 
-	Cvar_SetValue( "v_dark", 0.0f );
+	Cvar_DirectSet( &v_dark, "0" );
 }
 
 /*
@@ -703,7 +718,7 @@ void CL_DemoCompleted( void )
 	if( !CL_NextDemo() && !cls.changedemo )
 		UI_SetActiveMenu( true );
 
-	Cvar_SetValue( "v_dark", 0.0f );
+	Cvar_DirectSet( &v_dark, "0" );
 }
 
 /*
@@ -887,7 +902,7 @@ qboolean CL_DemoReadMessage( byte *buffer, size_t *length )
 	qboolean		swallowmessages = true;
 	static int	tdlastdemoframe = 0;
 	byte		*userbuf = NULL;
-	size_t		size;
+	size_t		size = 0;
 	byte		cmd;
 
 	if( !cls.demofile )
@@ -912,7 +927,8 @@ qboolean CL_DemoReadMessage( byte *buffer, size_t *length )
 		if( !cls.demofile ) break;
 		curpos = FS_Tell( cls.demofile );
 
-		CL_ReadDemoCmdHeader( &cmd, &demo.timestamp );
+		if( !CL_ReadDemoCmdHeader( &cmd, &demo.timestamp ))
+			return false;
 
 		fElapsedTime = CL_GetDemoPlaybackClock() - demo.starttime;
 		if( !cls.timedemo ) bSkipMessage = ((demo.timestamp - cl_serverframetime()) >= fElapsedTime) ? true : false;
@@ -1108,7 +1124,10 @@ void CL_FinishTimeDemo( void )
 	time = host.realtime - cls.td_starttime;
 	if( !time ) time = 1.0;
 
-	Con_Printf( "%i frames %5.3f seconds %5.3f fps\n", frames, time, frames / time );
+	Con_Printf( "timedemo result: %i frames %5.3f seconds %5.3f fps\n", frames, time, frames / time );
+
+	if( Sys_CheckParm( "-timedemo" ))
+		CL_Quit_f();
 }
 
 /*
@@ -1153,6 +1172,7 @@ void CL_StopPlayback( void )
 		// let game known about demo state
 		Cvar_FullSet( "cl_background", "0", FCVAR_READ_ONLY );
 		cls.state = ca_disconnected;
+		memset( &cls.serveradr, 0, sizeof( cls.serveradr ) );
 		cls.set_lastdemo = false;
 		S_StopBackgroundTrack();
 		cls.connect_time = 0;
@@ -1169,7 +1189,7 @@ void CL_StopPlayback( void )
 CL_GetDemoComment
 ==================
 */
-qboolean CL_GetDemoComment( const char *demoname, char *comment )
+int GAME_EXPORT CL_GetDemoComment( const char *demoname, char *comment )
 {
 	file_t		*demfile;
 	demoheader_t	demohdr;
@@ -1183,7 +1203,7 @@ qboolean CL_GetDemoComment( const char *demoname, char *comment )
 	demfile = FS_Open( demoname, "rb", false );
 	if( !demfile )
 	{
-		Q_strncpy( comment, "", MAX_STRING );
+		comment[0] = '\0';
 		return false;
 	}
 
@@ -1197,7 +1217,9 @@ qboolean CL_GetDemoComment( const char *demoname, char *comment )
 		return false;
 	}
 
-	if( demohdr.net_protocol != PROTOCOL_VERSION || demohdr.dem_protocol != DEMO_PROTOCOL )
+	if(( demohdr.net_protocol != PROTOCOL_VERSION &&
+		demohdr.net_protocol != PROTOCOL_LEGACY_VERSION ) ||
+		demohdr.dem_protocol != DEMO_PROTOCOL )
 	{
 		FS_Close( demfile );
 		Q_strncpy( comment, "<invalid protocol>", MAX_STRING );
@@ -1224,7 +1246,7 @@ qboolean CL_GetDemoComment( const char *demoname, char *comment )
 	// split comment to sections
 	Q_strncpy( comment, demohdr.mapname, CS_SIZE );
 	Q_strncpy( comment + CS_SIZE, demohdr.comment, CS_SIZE );
-	Q_strncpy( comment + CS_SIZE * 2, va( "%g sec", playtime ), CS_TIME );
+	Q_snprintf( comment + CS_SIZE * 2, CS_TIME, "%g sec", playtime );
 
 	// all done
 	FS_Close( demfile );
@@ -1289,7 +1311,7 @@ void CL_CheckStartupDemos( void )
 	}
 
 	// run demos loop in background mode
-	Cvar_SetValue( "v_dark", 1.0f );
+	Cvar_DirectSet( &v_dark, "1" );
 	cls.demos_pending = false;
 	cls.demonum = 0;
 	CL_NextDemo ();
@@ -1300,26 +1322,16 @@ void CL_CheckStartupDemos( void )
 CL_DemoGetName
 ==================
 */
-static void CL_DemoGetName( int lastnum, char *filename )
+static void CL_DemoGetName( int lastnum, char *filename, size_t size )
 {
-	int	a, b, c, d;
-
 	if( lastnum < 0 || lastnum > 9999 )
 	{
 		// bound
-		Q_strcpy( filename, "demo9999" );
+		Q_strncpy( filename, "demo9999", size );
 		return;
 	}
 
-	a = lastnum / 1000;
+	Q_snprintf( filename, size, "demo%04d", lastnum );
-	lastnum -= a * 1000;
-	b = lastnum / 100;
-	lastnum -= b * 100;
-	c = lastnum / 10;
-	lastnum -= c * 10;
-	d = lastnum;
-
-	Q_sprintf( filename, "demo%i%i%i%i", a, b, c, d );
 }
 
 /*
@@ -1373,8 +1385,10 @@ void CL_Record_f( void )
 		// scan for a free filename
 		for( n = 0; n < 10000; n++ )
 		{
-			CL_DemoGetName( n, demoname );
+			CL_DemoGetName( n, demoname, sizeof( demoname ));
-			if( !FS_FileExists( va( "%s.dem", demoname ), true ))
+			Q_snprintf( demopath, sizeof( demopath ), "%s.dem", demoname );
+
+			if( !FS_FileExists( demopath, true ))
 				break;
 		}
 
@@ -1387,9 +1401,9 @@ void CL_Record_f( void )
 	else Q_strncpy( demoname, name, sizeof( demoname ));
 
 	// open the demo file
-	Q_sprintf( demopath, "%s.dem", demoname );
+	Q_snprintf( demopath, sizeof( demopath ), "%s.dem", demoname );
 
-	// make sure what old demo is removed
+	// make sure that old demo is removed
 	if( FS_FileExists( demopath, false ))
 		FS_Delete( demopath );
 
@@ -1414,7 +1428,7 @@ void CL_PlayDemo_f( void )
 
 	if( Cmd_Argc() < 2 )
 	{
-		Con_Printf( S_USAGE "playdemo <demoname>\n" );
+		Con_Printf( S_USAGE "%s <demoname>\n", Cmd_Argv( 0 ));
 		return;
 	}
 
@@ -1461,7 +1475,7 @@ void CL_PlayDemo_f( void )
 	{
 		int	c, neg = false;
 
-		demo.header.host_fps = host_maxfps->value;
+		demo.header.host_fps = host_maxfps.value;
 
 		while(( c = FS_Getc( cls.demofile )) != '\n' )
 		{
@@ -1484,12 +1498,16 @@ void CL_PlayDemo_f( void )
 		return;
 	}
 
-	if( demo.header.net_protocol != PROTOCOL_VERSION || demo.header.dem_protocol != DEMO_PROTOCOL )
-	{
 	if( demo.header.dem_protocol != DEMO_PROTOCOL )
+	{
 		Con_Printf( S_ERROR "playdemo: demo protocol outdated (%i should be %i)\n", demo.header.dem_protocol, DEMO_PROTOCOL );
+		CL_DemoAborted();
+		return;
+	}
 
-		if( demo.header.net_protocol != PROTOCOL_VERSION )
+	if( demo.header.net_protocol != PROTOCOL_VERSION &&
+		demo.header.net_protocol != PROTOCOL_LEGACY_VERSION )
+	{
 		Con_Printf( S_ERROR "playdemo: net protocol outdated (%i should be %i)\n", demo.header.net_protocol, PROTOCOL_VERSION );
 		CL_DemoAborted();
 		return;
@@ -1523,6 +1541,7 @@ void CL_PlayDemo_f( void )
 
 	// g-cont. is this need?
 	Q_strncpy( cls.servername, demoname, sizeof( cls.servername ));
+	cls.legacymode = demo.header.net_protocol == PROTOCOL_LEGACY_VERSION;
 
 	// begin a playback demo
 }
@@ -1536,12 +1555,6 @@ timedemo <demoname>
 */
 void CL_TimeDemo_f( void )
 {
-	if( Cmd_Argc() != 2 )
-	{
-		Con_Printf( S_USAGE "timedemo <demoname>\n" );
-		return;
-	}
-
 	CL_PlayDemo_f ();
 
 	// cls.td_starttime will be grabbed at the second frame of the demo, so

engine/client/cl_efrag.c

@@ -14,11 +14,11 @@ GNU General Public License for more details.
 */
 
 #include "common.h"
-#include "client.h"
-#include "gl_local.h"
-#include "mod_local.h"
 #include "entity_types.h"
 #include "studio.h"
+#include "world.h" // BOX_ON_PLANE_SIDE
+#include "client.h"
+#include "xash3d_mathlib.h"
 
 /*
 ===============================================================================
@@ -33,46 +33,6 @@ static mnode_t	*r_pefragtopnode;
 static vec3_t	r_emins, r_emaxs;
 static cl_entity_t	*r_addent;
 
-/*
-================
-R_RemoveEfrags
-
-Call when removing an object from the world or moving it to another position
-================
-*/
-void R_RemoveEfrags( cl_entity_t *ent )
-{
-	efrag_t	*ef, *old, *walk, **prev;
-	
-	ef = ent->efrag;
-	
-	while( ef )
-	{
-		prev = &ef->leaf->efrags;
-		while( 1 )
-		{
-			walk = *prev;
-			if( !walk ) break;
-
-			if( walk == ef )
-			{	
-				// remove this fragment
-				*prev = ef->leafnext;
-				break;
-			}
-			else prev = &walk->leafnext;
-		}
-				
-		old = ef;
-		ef = ef->entnext;
-		
-		// put it on the free list
-		old->entnext = clgame.free_efrags;
-		clgame.free_efrags = old;
-	}
-	ent->efrag = NULL; 
-}
-
 /*
 ===================
 R_SplitEntityOnNode
@@ -103,7 +63,7 @@ static void R_SplitEntityOnNode( mnode_t *node )
 			return; // no free fragments...
 		}
 
-		clgame.free_efrags = clgame.free_efrags->entnext;
+		clgame.free_efrags = ef->entnext;
 		ef->entity = r_addent;
 
 		// add the entity link
@@ -188,8 +148,6 @@ void R_StoreEfrags( efrag_t **ppefrag, int framecount )
 		case mod_brush:
 		case mod_studio:
 		case mod_sprite:
-			pent = pefrag->entity;
-
 			if( pent->visframe != framecount )
 			{
 				if( CL_AddVisibleEntity( pent, ET_FRAGMENTED ))

engine/client/cl_events.c

@@ -63,7 +63,7 @@ void CL_CalcPlayerVelocity( int idx, vec3_t velocity )
 		if( dt != 0.0 )
 		{
 			VectorSubtract( clgame.entities[idx].curstate.velocity, clgame.entities[idx].prevstate.velocity, delta );
-			VectorScale( delta, 1.0 / dt, velocity );
+			VectorScale( delta, 1.0f / dt, velocity );
 		}
 		else
 		{
@@ -78,23 +78,48 @@ CL_DescribeEvent
 
 =============
 */
-void CL_DescribeEvent( int slot, int flags, const char *eventname )
+void CL_DescribeEvent( event_info_t *ei, int slot )
 {
-	int		idx = (slot & 31);
+	int		idx = (slot & 63) * 2;
 	con_nprint_t	info;
+	string origin_str = { 0 }; //, angles_str = { 0 };
 
-	if( !eventname || !cl_showevents->value )
+	if( !cl_showevents.value )
 		return;
 
-	// mark reliable as green and unreliable as red
+	info.time_to_live = 1.0f;
-	if( FBitSet( flags, FEV_RELIABLE ))
-		VectorSet( info.color, 0.0f, 1.0f, 0.0f );
-	else VectorSet( info.color, 1.0f, 0.0f, 0.0f );
-
-	info.time_to_live = 0.5f;
 	info.index = idx;
 
-	Con_NXPrintf( &info, "%i %f %s", slot, cl.time, eventname );
+	// mark reliable as green and unreliable as red
+	if( FBitSet( ei->flags, FEV_RELIABLE ))
+		VectorSet( info.color, 0.5f, 1.0f, 0.5f );
+	else VectorSet( info.color, 1.0f, 0.5f, 0.5f );
+
+	if( !VectorIsNull( ei->args.origin ))
+	{
+		Q_snprintf( origin_str, sizeof( origin_str ), "(%.2f,%.2f,%.2f)",
+			ei->args.origin[0], ei->args.origin[1], ei->args.origin[2]);
+	}
+
+	/*if( !VectorIsNull( ei->args.angles ))
+	{
+		Q_snprintf( angles_str, sizeof( angles_str ), "ang %.2f %.2f %.2f",
+			ei->args.angles[0], ei->args.angles[1], ei->args.angles[2]);
+	}*/
+
+	Con_NXPrintf( &info, "%i %.2f %c %s %s",
+		slot, cl.time,
+		(FBitSet( ei->flags, FEV_CLIENT ) ? 'c' :
+		FBitSet( ei->flags, FEV_SERVER ) ? 's' : '?'),
+		cl.event_precache[ei->index],
+		origin_str);
+
+	info.index++;
+
+	Con_NXPrintf( &info, "b(%i,%i) i(%i,%i) f(%.2f,%.2f)",
+		ei->args.bparam1, ei->args.bparam2,
+		ei->args.iparam1, ei->args.iparam2,
+		ei->args.fparam1, ei->args.fparam2);
 }
 
 /*
@@ -133,7 +158,7 @@ CL_EventIndex
 */
 word CL_EventIndex( const char *name )
 {
-	int	i;
+	word	i;
 
 	if( !COM_CheckString( name ))
 		return 0;
@@ -200,14 +225,25 @@ qboolean CL_FireEvent( event_info_t *ei, int slot )
 
 		if( ev->index == ei->index )
 		{
+			name = cl.event_precache[ei->index];
+
+			if( cl_trace_events.value )
+			{
+				Con_Printf( "^3EVENT %s AT %.2f %.2f %.2f\n"    // event name
+					"\t%.2f %.2f %i %i %s %s\n", // bool params
+					name, ei->args.origin[0], ei->args.origin[1], ei->args.origin[2],
+					ei->args.fparam1, ei->args.fparam2,
+					ei->args.iparam1, ei->args.iparam2,
+					ei->args.bparam1 ? "TRUE" : "FALSE", ei->args.bparam2 ? "TRUE" : "FALSE" );
+			}
+
 			if( ev->func )
 			{
-				CL_DescribeEvent( slot, ei->flags, cl.event_precache[ei->index] );
+				CL_DescribeEvent( ei, slot );
 				ev->func( &ei->args );
 				return true;
 			}
 
-			name = cl.event_precache[ei->index];
 			Con_Reportf( S_ERROR "CL_FireEvent: %s not hooked\n", name );
 			break;
 		}
@@ -393,7 +429,7 @@ void CL_ParseEvent( sizebuf_t *msg )
 		event_index = MSG_ReadUBitLong( msg, MAX_EVENT_BITS );
 
 		if( MSG_ReadOneBit( msg ))
-			packet_index = MSG_ReadUBitLong( msg, MAX_ENTITY_BITS );
+			packet_index = MSG_ReadUBitLong( msg, cls.legacymode ? MAX_LEGACY_ENTITY_BITS : MAX_ENTITY_BITS );
 		else packet_index = -1;
 
 		if( MSG_ReadOneBit( msg ))
@@ -450,7 +486,7 @@ CL_PlaybackEvent
 
 =============
 */
-void CL_PlaybackEvent( int flags, const edict_t *pInvoker, word eventindex, float delay, float *origin,
+void GAME_EXPORT CL_PlaybackEvent( int flags, const edict_t *pInvoker, word eventindex, float delay, float *origin,
 	float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 )
 {
 	event_args_t	args;
@@ -459,7 +495,7 @@ void CL_PlaybackEvent( int flags, const edict_t *pInvoker, word eventindex, floa
 		return;
 
 	// first check event for out of bounds
-	if( eventindex < 1 || eventindex > MAX_EVENTS )
+	if( eventindex < 1 || eventindex >= MAX_EVENTS )
 	{
 		Con_DPrintf( S_ERROR "CL_PlaybackEvent: invalid eventindex %i\n", eventindex );
 		return;

engine/client/cl_font.c

@@ -0,0 +1,350 @@
+/*
+cl_font.c - bare bones engine font manager
+Copyright (C) 2023 Alibek Omarov
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+*/
+
+#include "common.h"
+#include "filesystem.h"
+#include "client.h"
+#include "qfont.h"
+
+qboolean CL_FixedFont( cl_font_t *font )
+{
+	return font && font->valid && font->type == FONT_FIXED;
+}
+
+static int CL_LoadFontTexture( const char *fontname, uint texFlags, int *width )
+{
+	int font_width;
+	int tex;
+
+	if( !g_fsapi.FileExists( fontname, false ))
+		return 0;
+
+	tex = ref.dllFuncs.GL_LoadTexture( fontname, NULL, 0, texFlags );
+	if( !tex )
+		return 0;
+
+	font_width = REF_GET_PARM( PARM_TEX_WIDTH, tex );
+	if( !font_width )
+	{
+		ref.dllFuncs.GL_FreeTexture( tex );
+		return 0;
+	}
+
+	*width = font_width;
+	return tex;
+}
+
+qboolean Con_LoadFixedWidthFont( const char *fontname, cl_font_t *font, float scale, int rendermode, uint texFlags )
+{
+	int font_width, i;
+
+	if( font->valid )
+		return true; // already loaded
+
+	font->hFontTexture = CL_LoadFontTexture( fontname, texFlags, &font_width );
+	if( !font->hFontTexture )
+		return false;
+
+	font->type = FONT_FIXED;
+	font->valid = true;
+	font->scale = scale;
+	font->nearest = FBitSet( texFlags, TF_NEAREST );
+	font->rendermode = rendermode;
+	font->charHeight = Q_rint( font_width / 16 * scale );
+
+	for( i = 0; i < ARRAYSIZE( font->fontRc ); i++ )
+	{
+		font->fontRc[i].left   = ( i * font_width / 16 ) % font_width;
+		font->fontRc[i].right  = font->fontRc[i].left + font_width / 16;
+		font->fontRc[i].top    = ( i / 16 ) * ( font_width / 16 );
+		font->fontRc[i].bottom = font->fontRc[i].top + font_width / 16;
+
+		font->charWidths[i] = Q_rint( font_width / 16 * scale );
+	}
+
+	return true;
+}
+
+qboolean Con_LoadVariableWidthFont( const char *fontname, cl_font_t *font, float scale, int rendermode, uint texFlags )
+{
+	fs_offset_t length;
+	qfont_t src;
+	byte *pfile;
+	int font_width, i;
+
+	if( font->valid )
+		return true;
+
+	pfile = g_fsapi.LoadFile( fontname, &length, false );
+	if( !pfile )
+		return false;
+
+	if( length < sizeof( src ))
+	{
+		Mem_Free( pfile );
+		return false;
+	}
+
+	memcpy( &src, pfile, sizeof( src ));
+	Mem_Free( pfile );
+
+	font->hFontTexture = CL_LoadFontTexture( fontname, texFlags, &font_width );
+	if( !font->hFontTexture )
+		return false;
+
+	font->type = FONT_VARIABLE;
+	font->valid = true;
+	font->scale = scale;
+	font->nearest = FBitSet( texFlags, TF_NEAREST );
+	font->rendermode = rendermode;
+	font->charHeight = Q_rint( src.rowheight * scale );
+
+	for( i = 0; i < ARRAYSIZE( font->fontRc ); i++ )
+	{
+		const charinfo *ci = &src.fontinfo[i];
+
+		font->fontRc[i].left   = (word)ci->startoffset % font_width;
+		font->fontRc[i].right  = font->fontRc[i].left + ci->charwidth;
+		font->fontRc[i].top    = (word)ci->startoffset / font_width;
+		font->fontRc[i].bottom = font->fontRc[i].top + src.rowheight;
+
+		font->charWidths[i] = Q_rint( src.fontinfo[i].charwidth * scale );
+	}
+
+	return true;
+}
+
+void CL_FreeFont( cl_font_t *font )
+{
+	if( !font || !font->valid )
+		return;
+
+	ref.dllFuncs.GL_FreeTexture( font->hFontTexture );
+	memset( font, 0, sizeof( *font ));
+}
+
+static int CL_CalcTabStop( const cl_font_t *font, int x )
+{
+	int space = font->charWidths[' '];
+	int tab   = space * 6; // 6 spaces
+	int stop  = tab - x % tab;
+
+	if( stop < space )
+		return tab * 2 - x % tab; // select next
+
+	return stop;
+}
+
+int CL_DrawCharacter( float x, float y, int number, rgba_t color, cl_font_t *font, int flags )
+{
+	wrect_t *rc;
+	float w, h;
+	float s1, t1, s2, t2, half = 0.5f;
+	int texw, texh;
+
+	if( !font || !font->valid || y < -font->charHeight )
+		return 0;
+
+	// check if printable
+	if( number <= 32 )
+	{
+		if( number == ' ' )
+			return font->charWidths[' '];
+		else if( number == '\t' )
+			return CL_CalcTabStop( font, x );
+		return 0;
+	}
+
+	if( FBitSet( flags, FONT_DRAW_UTF8 ))
+		number = Con_UtfProcessChar( number & 255 );
+	else number &= 255;
+
+	if( !number || !font->charWidths[number])
+		return 0;
+
+	R_GetTextureParms( &texw, &texh, font->hFontTexture );
+	if( !texw || !texh )
+		return font->charWidths[number];
+
+	rc = &font->fontRc[number];
+	if( font->nearest || font->scale <= 1.0f )
+		half = 0;
+
+	s1 = ((float)rc->left + half ) / texw;
+	t1 = ((float)rc->top + half ) / texh;
+	s2 = ((float)rc->right - half ) / texw;
+	t2 = ((float)rc->bottom - half ) / texh;
+	w = ( rc->right - rc->left ) * font->scale;
+	h = ( rc->bottom - rc->top ) * font->scale;
+
+	if( FBitSet( flags, FONT_DRAW_HUD ))
+		SPR_AdjustSize( &x, &y, &w, &h );
+
+	if( !FBitSet( flags, FONT_DRAW_NORENDERMODE ))
+		ref.dllFuncs.GL_SetRenderMode( font->rendermode );
+
+	// don't apply color to fixed fonts it's already colored
+	if( font->type != FONT_FIXED || REF_GET_PARM( PARM_TEX_GLFORMAT, font->hFontTexture ) == 0x8045 ) // GL_LUMINANCE8_ALPHA8
+		ref.dllFuncs.Color4ub( color[0], color[1], color[2], color[3] );
+	else ref.dllFuncs.Color4ub( 255, 255, 255, color[3] );
+	ref.dllFuncs.R_DrawStretchPic( x, y, w, h, s1, t1, s2, t2, font->hFontTexture );
+
+	return font->charWidths[number];
+}
+
+int CL_DrawString( float x, float y, const char *s, rgba_t color, cl_font_t *font, int flags )
+{
+	rgba_t current_color;
+	int draw_len = 0;
+
+	if( !font || !font->valid )
+		return 0;
+
+	if( FBitSet( flags, FONT_DRAW_UTF8 ))
+		Con_UtfProcessChar( 0 ); // clear utf state
+
+	if( !FBitSet( flags, FONT_DRAW_NORENDERMODE ))
+		ref.dllFuncs.GL_SetRenderMode( font->rendermode );
+
+	Vector4Copy( color, current_color );
+
+	while( *s )
+	{
+		if( *s == '\n' )
+		{
+			s++;
+
+			if( !*s )
+				break;
+
+			// some client functions ignore newlines
+			if( !FBitSet( flags, FONT_DRAW_NOLF ))
+			{
+				draw_len = 0;
+				y += font->charHeight;
+			}
+
+			if( FBitSet( flags, FONT_DRAW_RESETCOLORONLF ))
+				 Vector4Copy( color, current_color );
+			continue;
+		}
+
+		if( IsColorString( s ))
+		{
+			// don't copy alpha
+			if( !FBitSet( flags, FONT_DRAW_FORCECOL ))
+				VectorCopy( g_color_table[ColorIndex(*( s + 1 ))], current_color );
+
+			s += 2;
+			continue;
+		}
+
+		// skip setting rendermode, it was changed for this string already
+		draw_len += CL_DrawCharacter( x + draw_len, y, (byte)*s, current_color, font, flags | FONT_DRAW_NORENDERMODE );
+
+		s++;
+	}
+
+	return draw_len;
+}
+
+int CL_DrawStringf( cl_font_t *font, float x, float y, rgba_t color, int flags, const char *fmt, ... )
+{
+	va_list va;
+	char buf[MAX_VA_STRING];
+
+	va_start( va, fmt );
+	Q_vsnprintf( buf, sizeof( buf ), fmt, va );
+	va_end( va );
+
+	return CL_DrawString( x, y, buf, color, font, flags );
+}
+
+void CL_DrawCharacterLen( cl_font_t *font, int number, int *width, int *height )
+{
+	if( !font || !font->valid ) return;
+	if( width )
+	{
+		if( number == '\t' )
+			*width = CL_CalcTabStop( font, 0 ); // at least return max tabstop
+		else *width = font->charWidths[number & 255];
+	}
+	if( height ) *height = font->charHeight;
+}
+
+void CL_DrawStringLen( cl_font_t *font, const char *s, int *width, int *height, int flags )
+{
+	int draw_len = 0;
+
+	if( !font || !font->valid )
+		return;
+
+	if( height )
+		*height = font->charHeight;
+
+	if( width )
+		*width = 0;
+
+	if( !COM_CheckString( s ))
+		return;
+
+	if( FBitSet( flags, FONT_DRAW_UTF8 ))
+		Con_UtfProcessChar( 0 ); // reset utf state
+
+	while( *s )
+	{
+		int number;
+
+		if( *s == '\n' )
+		{
+			// BUG: no check for end string here
+			// but high chances somebody's relying on this
+			s++;
+			draw_len = 0;
+			if( !FBitSet( flags, FONT_DRAW_NOLF ))
+			{
+				if( height )
+					*height += font->charHeight;
+			}
+			continue;
+		}
+		else if( *s == '\t' )
+		{
+			draw_len += CL_CalcTabStop( font, 0 ); // at least return max tabstop
+			s++;
+			continue;
+		}
+
+		if( IsColorString( s ))
+		{
+			s += 2;
+			continue;
+		}
+
+		if( FBitSet( flags, FONT_DRAW_UTF8 ))
+			number = Con_UtfProcessChar( (byte)*s );
+		else number = (byte)*s;
+
+		if( number )
+		{
+			draw_len += font->charWidths[number];
+
+			if( draw_len > *width )
+				*width = draw_len;
+		}
+
+		s++;
+	}
+}

engine/client/cl_frame.c

@@ -17,7 +17,6 @@ GNU General Public License for more details.
 #include "client.h"
 #include "net_encode.h"
 #include "entity_types.h"
-#include "gl_local.h"
 #include "pm_local.h"
 #include "cl_tent.h"
 #include "studio.h"
@@ -59,10 +58,13 @@ void CL_UpdatePositions( cl_entity_t *ent )
 
 	ent->current_position = (ent->current_position + 1) & HISTORY_MASK;
 	ph = &ent->ph[ent->current_position];
-
 	VectorCopy( ent->curstate.origin, ph->origin );
 	VectorCopy( ent->curstate.angles, ph->angles );
-	ph->animtime = ent->curstate.animtime;	// !!!
+
+	if( ent->model && ent->model->type == mod_brush )
+		ph->animtime = ent->curstate.animtime;
+	else
+		ph->animtime = cl.time;
 }
 
 /*
@@ -102,7 +104,7 @@ qboolean CL_EntityTeleported( cl_entity_t *ent )
 	VectorSubtract( ent->curstate.origin, ent->prevstate.origin, delta );
 
 	// compute potential max movement in units per frame and compare with entity movement
-	maxlen = ( clgame.movevars.maxvelocity * ( 1.0 / GAME_FPS ));
+	maxlen = ( clgame.movevars.maxvelocity * ( 1.0f / GAME_FPS ));
 	len = VectorLength( delta );
 
 	return (len > maxlen);
@@ -132,6 +134,9 @@ some ents will be ignore lerping
 */
 qboolean CL_EntityIgnoreLerp( cl_entity_t *e )
 {
+	if( cl_nointerp.value > 0.f )
+		return true;
+
 	if( e->model && e->model->type == mod_alias )
 		return false;
 
@@ -217,7 +222,7 @@ void CL_UpdateLatchedVars( cl_entity_t *ent )
 
 	if( ent->curstate.sequence != ent->prevstate.sequence )
 	{
-		memcpy( ent->prevstate.blending, ent->latched.prevseqblending, sizeof( ent->prevstate.blending ));
+		memcpy( ent->latched.prevseqblending, ent->prevstate.blending, sizeof( ent->latched.prevseqblending ));
 		ent->latched.prevsequence = ent->prevstate.sequence;
 		ent->latched.sequencetime = ent->curstate.animtime;
 	}
@@ -230,6 +235,33 @@ void CL_UpdateLatchedVars( cl_entity_t *ent )
 		clgame.drawFuncs.CL_UpdateLatchedVars( ent, false );
 }
 
+/*
+====================
+CL_GetStudioEstimatedFrame
+
+====================
+*/
+static float CL_GetStudioEstimatedFrame( cl_entity_t *ent )
+{
+	studiohdr_t	*pstudiohdr;
+	mstudioseqdesc_t	*pseqdesc;
+	int		sequence;
+
+	if( ent->model != NULL && ent->model->type == mod_studio )
+	{
+		pstudiohdr = (studiohdr_t *)Mod_StudioExtradata( ent->model );
+
+		if( pstudiohdr )
+		{
+			sequence = bound( 0, ent->curstate.sequence, pstudiohdr->numseq - 1 );
+			pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + sequence;
+			return ref.dllFuncs.R_StudioEstimateFrame( ent, pseqdesc, cl.time );
+		}
+	}
+
+	return 0;
+}
+
 /*
 ====================
 CL_ResetLatchedVars
@@ -281,7 +313,7 @@ void CL_ProcessEntityUpdate( cl_entity_t *ent )
 	if( FBitSet( ent->curstate.entityType, ENTITY_NORMAL ))
 		COM_NormalizeAngles( ent->curstate.angles );
 
-	parametric = CL_ParametricMove( ent );
+	parametric = ent->curstate.starttime != 0.0f && ent->curstate.impacttime != 0.0f;
 
 	// allow interpolation on bmodels too
 	if( ent->model && ent->model->type == mod_brush )
@@ -320,7 +352,7 @@ find two timestamps
 qboolean CL_FindInterpolationUpdates( cl_entity_t *ent, float targettime, position_history_t **ph0, position_history_t **ph1 )
 {
 	qboolean	extrapolate = true;
-	int	i, i0, i1, imod;
+	uint		i, i0, i1, imod;
 	float	at;
 
 	imod = ent->current_position;
@@ -330,7 +362,7 @@ qboolean CL_FindInterpolationUpdates( cl_entity_t *ent, float targettime, positi
 	for( i = 1; i < HISTORY_MAX - 1; i++ )
 	{
 		at = ent->ph[( imod - i ) & HISTORY_MASK].animtime;
-		if( at == 0.0 ) break;
+		if( at == 0.0f ) break;
 
 		if( targettime > at )
 		{
@@ -377,7 +409,7 @@ void CL_PureOrigin( cl_entity_t *ent, float t, vec3_t outorigin, vec3_t outangle
 
 		VectorSubtract( ph0->origin, ph1->origin, delta );
 
-		if( t0 != t1 )
+		if( !Q_equal( t0, t1 ))
 			frac = ( t - t1 ) / ( t0 - t1 );
 		else frac = 1.0f;
 
@@ -432,13 +464,13 @@ int CL_InterpolateModel( cl_entity_t *e )
 	if( cl.maxclients <= 1 )
 		return 1;
 
-	if( e->model->type == mod_brush && !cl_bmodelinterp->value )
+	if( e->model->type == mod_brush && !cl_bmodelinterp.value )
 		return 1;
 
 	if( cl.local.moving && cl.local.onground == e->index )
 		return 1;
 
-	t = cl.time - cl_interp->value;
+	t = cl.time - cl_interp.value;
 	CL_FindInterpolationUpdates( e, t, &ph0, &ph1 );
 
 	if( ph0 == NULL || ph1 == NULL )
@@ -457,7 +489,9 @@ int CL_InterpolateModel( cl_entity_t *e )
 		return 0;
 	}
 
-	if( t2 == t1 )
+	// HACKHACK: workaround buggy position history animtime
+	// going backward sometimes
+	if( Q_equal( t2, t1 ) || t2 < t1 )
 	{
 		VectorCopy( ph0->origin, e->origin );
 		VectorCopy( ph0->angles, e->angles );
@@ -500,9 +534,16 @@ void CL_ComputePlayerOrigin( cl_entity_t *ent )
 	vec3_t	origin;
 	vec3_t	angles;
 
-	if( !ent->player || ent->index == ( cl.playernum + 1 ))
+	if( !ent->player )
 		return;
 
+	if( cl_nointerp.value > 0.f )
+	{
+		VectorCopy( ent->curstate.angles, ent->angles );
+		VectorCopy( ent->curstate.origin, ent->origin );
+		return;
+	}
+
 	if( cls.demoplayback == DEMO_QUAKE1 )
 	{
 		// quake lerping is easy
@@ -514,7 +555,7 @@ void CL_ComputePlayerOrigin( cl_entity_t *ent )
 		return;
 	}
 
-	targettime = cl.time - cl_interp->value;
+	targettime = cl.time - cl_interp.value;
 	CL_PureOrigin( ent, targettime, origin, angles );
 
 	VectorCopy( angles, ent->angles );
@@ -613,6 +654,24 @@ FRAME PARSING
 
 =========================================================================
 */
+static qboolean CL_ParseEntityNumFromPacket( sizebuf_t *msg, int *newnum )
+{
+	if( cls.legacymode )
+	{
+		*newnum = MSG_ReadWord( msg );
+		if( *newnum == 0 )
+			return false;
+	}
+	else
+	{
+		*newnum = MSG_ReadUBitLong( msg, MAX_ENTITY_BITS );
+		if( *newnum == LAST_EDICT )
+			return false;
+	}
+
+	return true;
+}
+
 /*
 =================
 CL_FlushEntityPacket
@@ -633,8 +692,8 @@ void CL_FlushEntityPacket( sizebuf_t *msg )
 	// read it all, but ignore it
 	while( 1 )
 	{
-		newnum = MSG_ReadUBitLong( msg, MAX_ENTITY_BITS );
+		if( !CL_ParseEntityNumFromPacket( msg, &newnum ))
-		if( newnum == LAST_EDICT ) break; // done
+			break; // done
 
 		if( MSG_CheckOverflow( msg ))
 			Host_Error( "CL_FlushEntityPacket: overflow\n" );
@@ -729,7 +788,10 @@ int CL_ParsePacketEntities( sizebuf_t *msg, qboolean delta )
 		CL_WriteDemoJumpTime();
 
 	// sentinel count. save it for debug checking
-	count = ( MSG_ReadUBitLong( msg, MAX_VISIBLE_PACKET_BITS ) + 1 );
+	if( cls.legacymode )
+		count = MSG_ReadWord( msg );
+	else count = MSG_ReadUBitLong( msg, MAX_VISIBLE_PACKET_BITS ) + 1;
+
 	newframe = &cl.frames[cl.parsecountmod];
 
 	// allocate parse entities
@@ -803,11 +865,12 @@ int CL_ParsePacketEntities( sizebuf_t *msg, qboolean delta )
 
 	while( 1 )
 	{
-		newnum = MSG_ReadUBitLong( msg, MAX_ENTITY_BITS );
+		if( !CL_ParseEntityNumFromPacket( msg, &newnum ))
-		if( newnum == LAST_EDICT ) break; // end of packet entities
+			break; // done
 
 		if( MSG_CheckOverflow( msg ))
 			Host_Error( "CL_ParsePacketEntities: overflow\n" );
+
 		player = CL_IsPlayerIndex( newnum );
 
 		while( oldnum < newnum )
@@ -916,9 +979,25 @@ all the visible entities should pass this filter
 */
 qboolean CL_AddVisibleEntity( cl_entity_t *ent, int entityType )
 {
+	qboolean draw_player = true;
+
 	if( !ent || !ent->model )
 		return false;
 
+	// don't add the player in firstperson mode
+	if( RP_LOCALCLIENT( ent ))
+	{
+		cl.local.apply_effects = true;
+
+		if( !CL_IsThirdPerson( ) && ( ent->index == cl.viewentity ))
+		{
+			// we don't draw player in default renderer in firstperson mode
+			// but let the client.dll know about player entity anyway
+			// for use in custom renderers
+			draw_player = false;
+		}
+	}
+
 	// check for adding this entity
 	if( !clgame.dllFuncs.pfnAddEntity( entityType, ent, ent->model->name ))
 	{
@@ -928,28 +1007,23 @@ qboolean CL_AddVisibleEntity( cl_entity_t *ent, int entityType )
 		return false;
 	}
 
-	// don't add the player in firstperson mode
+	if( !draw_player )
-	if( RP_LOCALCLIENT( ent ) && !CL_IsThirdPerson( ) && ( ent->index == cl.viewentity ))
 		return false;
 
 	if( entityType == ET_BEAM )
 	{
-		CL_AddCustomBeam( ent );
+		ref.dllFuncs.CL_AddCustomBeam( ent );
 		return true;
 	}
-	else if( !R_AddEntity( ent, entityType ))
+	else if( !ref.dllFuncs.R_AddEntity( ent, entityType ))
 	{
 		return false;
 	}
 
 	// because pTemp->entity.curstate.effects
 	// is already occupied by FTENT_FLICKER
-	if( entityType != ET_TEMPENTITY )
+	if( entityType != ET_TEMPENTITY && !RP_LOCALCLIENT( ent ) )
 	{
-		// no reason to do it twice
-		if( RP_LOCALCLIENT( ent ))
-			cl.local.apply_effects = false;
-
 		// apply client-side effects
 		CL_AddEntityEffects( ent );
 
@@ -1001,7 +1075,6 @@ void CL_LinkPlayers( frame_t *frame )
 	// apply muzzleflash to weaponmodel
 	if( ent && FBitSet( ent->curstate.effects, EF_MUZZLEFLASH ))
 		SetBits( clgame.viewent.curstate.effects, EF_MUZZLEFLASH );
-	cl.local.apply_effects = true;
 
 	// check all the clients but add only visible
 	for( i = 0, state = frame->playerstate; i < MAX_CLIENTS; i++, state++ )
@@ -1040,6 +1113,9 @@ void CL_LinkPlayers( frame_t *frame )
 
 		if ( i == cl.playernum )
 		{
+			// using interpolation only for local player angles
+			CL_ComputePlayerOrigin( ent );
+
 			if( cls.demoplayback == DEMO_QUAKE1 )
 				VectorLerp( ent->prevstate.origin, cl.lerpFrac, ent->curstate.origin, cl.simorg );
 			VectorCopy( cl.simorg, ent->origin );
@@ -1109,7 +1185,7 @@ void CL_LinkPacketEntities( frame_t *frame )
 		if( ent->curstate.rendermode == kRenderNormal )
 		{
 			// auto 'solid' faces
-			if( FBitSet( ent->model->flags, MODEL_TRANSPARENT ) && CL_IsQuakeCompatible( ))
+			if( FBitSet( ent->model->flags, MODEL_TRANSPARENT ) && Host_IsQuakeCompatible( ))
 			{
 				ent->curstate.rendermode = kRenderTransAlpha;
 				ent->curstate.renderamt = 255;
@@ -1186,7 +1262,7 @@ void CL_LinkPacketEntities( frame_t *frame )
 			if( ent->model->type == mod_studio )
 			{
 				if( interpolate && FBitSet( host.features, ENGINE_COMPUTE_STUDIO_LERP ))
-					R_StudioLerpMovement( ent, cl.time, ent->origin, ent->angles );
+					ref.dllFuncs.R_StudioLerpMovement( ent, cl.time, ent->origin, ent->angles );
 			}
 		}
 
@@ -1257,8 +1333,6 @@ void CL_EmitEntities( void )
 {
 	if( cl.paused ) return; // don't waste time
 
-	R_ClearScene ();
-
 	// not in server yet, no entities to redraw
 	if( cls.state != ca_active || !cl.validsequence )
 		return;
@@ -1268,7 +1342,7 @@ void CL_EmitEntities( void )
 		return;
 
 	// animate lightestyles
-	CL_RunLightStyles ();
+	ref.dllFuncs.CL_RunLightStyles ();
 
 	// decay dynamic lights
 	CL_DecayLights ();
@@ -1279,9 +1353,7 @@ void CL_EmitEntities( void )
 	// set client ideal pitch when mlook is disabled
 	CL_SetIdealPitch ();
 
-	// clear the scene befor start new frame
+	ref.dllFuncs.R_ClearScene ();
-	if( clgame.drawFuncs.R_ClearScene != NULL )
-		clgame.drawFuncs.R_ClearScene();
 
 	// link all the visible clients first
 	CL_LinkPlayers ( &cl.frames[cl.parsecountmod] );
@@ -1325,7 +1397,7 @@ qboolean CL_GetEntitySpatialization( channel_t *ch )
 
 	if(( ch->entnum - 1 ) == cl.playernum )
 	{
-		VectorCopy( RI.vieworg, ch->origin );
+		VectorCopy( refState.vieworg, ch->origin );
 		return true;
 	}
 
@@ -1333,27 +1405,19 @@ qboolean CL_GetEntitySpatialization( channel_t *ch )
 	ent = CL_GetEntityByIndex( ch->entnum );
 
 	// entity is not present on the client but has valid origin
-	if( !ent || !ent->index || ent->curstate.messagenum == 0 )
+	if( !ent || !ent->model || ent->curstate.messagenum != cl.parsecount )
 		return valid_origin;
 
-#if 0
-	// uncomment this if you want enable additional check by PVS
-	if( ent->curstate.messagenum != cl.parsecount )
-		return valid_origin;
-#endif
-	ch->movetype = ent->curstate.movetype;
-
 	// setup origin
-	VectorAverage( ent->curstate.mins, ent->curstate.maxs, ch->origin );
+	if( ent->model->type == mod_brush )
-	VectorAdd( ch->origin, ent->curstate.origin, ch->origin );
+	{
-
+		VectorAverage( ent->model->mins, ent->model->maxs, ch->origin );
-	// setup mins\maxs
+		VectorAdd( ent->origin, ch->origin, ch->origin );
-	VectorAdd( ent->curstate.mins, ent->curstate.origin, ch->absmin );
+	}
-	VectorAdd( ent->curstate.maxs, ent->curstate.origin, ch->absmax );
+	else
-
+	{
-	// setup radius
+		VectorCopy( ent->origin, ch->origin );
-	if( ent->model != NULL && ent->model->radius ) ch->radius = ent->model->radius;
+	}
-	else ch->radius = RadiusFromBounds( ent->curstate.mins, ent->curstate.maxs );
 
 	return true;
 }
@@ -1371,12 +1435,15 @@ qboolean CL_GetMovieSpatialization( rawchan_t *ch )
 		return valid_origin;
 
 	// setup origin
-	VectorAverage( ent->curstate.mins, ent->curstate.maxs, ch->origin );
+	if( ent->model->type == mod_brush )
-	VectorAdd( ch->origin, ent->curstate.origin, ch->origin );
+	{
-
+		VectorAverage( ent->model->mins, ent->model->maxs, ch->origin );
-	// setup radius
+		VectorAdd( ent->origin, ch->origin, ch->origin );
-	if( ent->model != NULL && ent->model->radius ) ch->radius = ent->model->radius;
+	}
-	else ch->radius = RadiusFromBounds( ent->curstate.mins, ent->curstate.maxs );
+	else
+	{
+		VectorCopy( ent->origin, ch->origin );
+	}
 
 	return true;
 }

engine/client/cl_gameui.c

@@ -16,11 +16,11 @@ GNU General Public License for more details.
 #include "common.h"
 #include "client.h"
 #include "const.h"
-#include "gl_local.h"
 #include "library.h"
 #include "input.h"
+#include "server.h" // !!svgame.hInstance
+#include "vid_common.h"
 
-static MENUAPI	GetMenuAPI;
 static void 	UI_UpdateUserinfo( void );
 
 gameui_static_t	gameui;
@@ -47,7 +47,7 @@ void UI_UpdateMenu( float realtime )
 	gameui.globals->frametime = host.realframetime;
 	gameui.globals->demoplayback = cls.demoplayback;
 	gameui.globals->demorecording = cls.demorecording;
-	gameui.globals->allow_console = host.allow_console;
+	gameui.globals->developer = host.allow_console;
 
 	gameui.dllFuncs.pfnRedraw( realtime );
 	UI_UpdateUserinfo();
@@ -135,7 +135,162 @@ qboolean UI_IsVisible( void )
 	return gameui.dllFuncs.pfnIsVisible();
 }
 
-static void UI_DrawLogo( const char *filename, float x, float y, float width, float height )
+/*
+=======================
+UI_AddTouchButtonToList
+
+send button parameters to menu
+=======================
+*/
+void UI_AddTouchButtonToList( const char *name, const char *texture, const char *command, unsigned char *color, int flags )
+{
+	if( gameui.dllFuncs2.pfnAddTouchButtonToList )
+	{
+		gameui.dllFuncs2.pfnAddTouchButtonToList( name, texture, command, color, flags );
+	}
+}
+
+/*
+=================
+UI_ResetPing
+
+notify gameui dll about latency reset
+=================
+*/
+void UI_ResetPing( void )
+{
+	if( gameui.dllFuncs2.pfnResetPing )
+	{
+		gameui.dllFuncs2.pfnResetPing( );
+	}
+}
+
+/*
+=================
+UI_ShowConnectionWarning
+
+show connection warning dialog implemented by gameui dll
+=================
+*/
+void UI_ShowConnectionWarning( void )
+{
+	if( cls.state != ca_connected )
+		return;
+
+	if( Host_IsLocalClient() )
+		return;
+
+	if( ++cl.lostpackets == 8 )
+	{
+		CL_Disconnect();
+		if( gameui.dllFuncs2.pfnShowConnectionWarning )
+		{
+			gameui.dllFuncs2.pfnShowConnectionWarning();
+		}
+		Con_DPrintf( S_WARN "Too many lost packets! Showing Network options menu\n" );
+	}
+}
+
+
+/*
+=================
+UI_ShowConnectionWarning
+
+show update dialog
+=================
+*/
+void UI_ShowUpdateDialog( qboolean preferStore )
+{
+	if( gameui.dllFuncs2.pfnShowUpdateDialog )
+	{
+		gameui.dllFuncs2.pfnShowUpdateDialog( preferStore );
+	}
+
+	Con_Printf( S_WARN "This version is not supported anymore. To continue, install latest engine version\n" );
+}
+
+/*
+=================
+UI_ShowConnectionWarning
+
+show message box
+=================
+*/
+void UI_ShowMessageBox( const char *text )
+{
+	if( gameui.dllFuncs2.pfnShowMessageBox )
+	{
+		gameui.dllFuncs2.pfnShowMessageBox( text );
+	}
+}
+
+void UI_ConnectionProgress_Disconnect( void )
+{
+	if( gameui.dllFuncs2.pfnConnectionProgress_Disconnect )
+	{
+		gameui.dllFuncs2.pfnConnectionProgress_Disconnect( );
+	}
+}
+
+void UI_ConnectionProgress_Download( const char *pszFileName, const char *pszServerName, const char *pszServerPath, int iCurrent, int iTotal, const char *comment )
+{
+	if( !gameui.dllFuncs2.pfnConnectionProgress_Download )
+		return;
+
+	if( pszServerPath )
+	{
+		char serverpath[MAX_SYSPATH];
+
+		Q_snprintf( serverpath, sizeof( serverpath ), "%s%s", pszServerName, pszServerPath );
+		gameui.dllFuncs2.pfnConnectionProgress_Download( pszFileName, serverpath, iCurrent, iTotal, comment );
+	}
+	else
+	{
+		gameui.dllFuncs2.pfnConnectionProgress_Download( pszFileName, pszServerName, iCurrent, iTotal, comment );
+	}
+}
+
+void UI_ConnectionProgress_DownloadEnd( void )
+{
+	if( gameui.dllFuncs2.pfnConnectionProgress_DownloadEnd )
+	{
+		gameui.dllFuncs2.pfnConnectionProgress_DownloadEnd( );
+	}
+}
+
+void UI_ConnectionProgress_Precache( void )
+{
+	if( gameui.dllFuncs2.pfnConnectionProgress_Precache )
+	{
+		gameui.dllFuncs2.pfnConnectionProgress_Precache( );
+	}
+}
+
+void UI_ConnectionProgress_Connect( const char *server ) // NULL for local server
+{
+	if( gameui.dllFuncs2.pfnConnectionProgress_Connect )
+	{
+		gameui.dllFuncs2.pfnConnectionProgress_Connect( server );
+	}
+}
+
+void UI_ConnectionProgress_ChangeLevel( void )
+{
+	if( gameui.dllFuncs2.pfnConnectionProgress_ChangeLevel )
+	{
+		gameui.dllFuncs2.pfnConnectionProgress_ChangeLevel( );
+	}
+}
+
+void UI_ConnectionProgress_ParseServerInfo( const char *server )
+{
+	if( gameui.dllFuncs2.pfnConnectionProgress_ParseServerInfo )
+	{
+		gameui.dllFuncs2.pfnConnectionProgress_ParseServerInfo( server );
+	}
+}
+
+static void GAME_EXPORT UI_DrawLogo( const char *filename, float x, float y, float width, float height )
 {
 	static float	cin_time;
 	static int	last_frame = -1;
@@ -154,7 +309,7 @@ static void UI_DrawLogo( const char *filename, float x, float y, float width, fl
 
 		// run cinematic if not
 		Q_snprintf( path, sizeof( path ), "media/%s", filename );
-		COM_DefaultExtension( path, ".avi" );
+		COM_DefaultExtension( path, ".avi", sizeof( path ));
 		fullpath = FS_GetDiskPath( path, false );
 
 		if( FS_FileExists( path, false ) && !fullpath )
@@ -201,20 +356,20 @@ static void UI_DrawLogo( const char *filename, float x, float y, float width, fl
 		redraw = true;
 	}
 
-	R_DrawStretchRaw( x, y, width, height, gameui.logo_xres, gameui.logo_yres, cin_data, redraw );
+	ref.dllFuncs.R_DrawStretchRaw( x, y, width, height, gameui.logo_xres, gameui.logo_yres, cin_data, redraw );
 }
 
-static int UI_GetLogoWidth( void )
+static int GAME_EXPORT UI_GetLogoWidth( void )
 {
 	return gameui.logo_xres;
 }
 
-static int UI_GetLogoHeight( void )
+static int GAME_EXPORT UI_GetLogoHeight( void )
 {
 	return gameui.logo_yres;
 }
 
-static float UI_GetLogoLength( void )
+static float GAME_EXPORT UI_GetLogoLength( void )
 {
 	return gameui.logo_length;
 }
@@ -248,7 +403,7 @@ static void UI_ConvertGameInfo( GAMEINFO *out, gameinfo_t *in )
 	Q_strncpy( out->startmap, in->startmap, sizeof( out->startmap ));
 	Q_strncpy( out->trainmap, in->trainmap, sizeof( out->trainmap ));
 	Q_strncpy( out->title, in->title, sizeof( out->title ));
-	Q_strncpy( out->version, va( "%g", in->version ), sizeof( out->version ));
+	Q_snprintf( out->version, sizeof( out->version ), "%g", in->version );
 
 	Q_strncpy( out->game_url, in->game_url, sizeof( out->game_url ));
 	Q_strncpy( out->update_url, in->update_url, sizeof( out->update_url ));
@@ -259,57 +414,15 @@ static void UI_ConvertGameInfo( GAMEINFO *out, gameinfo_t *in )
 	out->gamemode = in->gamemode;
 
 	if( in->nomodels )
-		out->flags |= GFL_NOMODELS;
+		SetBits( out->flags, GFL_NOMODELS );
 	if( in->noskills )
-		out->flags |= GFL_NOSKILLS;
+		SetBits( out->flags, GFL_NOSKILLS );
-}
+	if( in->render_picbutton_text )
-
+		SetBits( out->flags, GFL_RENDER_PICBUTTON_TEXT );
-static qboolean PIC_Scissor( float *x, float *y, float *width, float *height, float *u0, float *v0, float *u1, float *v1 )
+	if( in->hd_background )
-{
+		SetBits( out->flags, GFL_HD_BACKGROUND );
-	float	dudx, dvdy;
+	if( in->animated_title )
-
+		SetBits( out->flags, GFL_ANIMATED_TITLE );
-	// clip sub rect to sprite
-	if(( width == 0 ) || ( height == 0 ))
-		return false;
-
-	if( *x + *width <= gameui.ds.scissor_x )
-		return false;
-	if( *x >= gameui.ds.scissor_x + gameui.ds.scissor_width )
-		return false;
-	if( *y + *height <= gameui.ds.scissor_y )
-		return false;
-	if( *y >= gameui.ds.scissor_y + gameui.ds.scissor_height )
-		return false;
-
-	dudx = (*u1 - *u0) / *width;
-	dvdy = (*v1 - *v0) / *height;
-
-	if( *x < gameui.ds.scissor_x )
-	{
-		*u0 += (gameui.ds.scissor_x - *x) * dudx;
-		*width -= gameui.ds.scissor_x - *x;
-		*x = gameui.ds.scissor_x;
-	}
-
-	if( *x + *width > gameui.ds.scissor_x + gameui.ds.scissor_width )
-	{
-		*u1 -= (*x + *width - (gameui.ds.scissor_x + gameui.ds.scissor_width)) * dudx;
-		*width = gameui.ds.scissor_x + gameui.ds.scissor_width - *x;
-	}
-
-	if( *y < gameui.ds.scissor_y )
-	{
-		*v0 += (gameui.ds.scissor_y - *y) * dvdy;
-		*height -= gameui.ds.scissor_y - *y;
-		*y = gameui.ds.scissor_y;
-	}
-
-	if( *y + *height > gameui.ds.scissor_y + gameui.ds.scissor_height )
-	{
-		*v1 -= (*y + *height - (gameui.ds.scissor_y + gameui.ds.scissor_height)) * dvdy;
-		*height = gameui.ds.scissor_y + gameui.ds.scissor_height - *y;
-	}
-	return true;
 }
 
 /*
@@ -330,10 +443,10 @@ static void PIC_DrawGeneric( float x, float y, float width, float height, const
 	if( prc )
 	{
 		// calc user-defined rectangle
-		s1 = (float)prc->left / (float)w;
+		s1 = prc->left / (float)w;
-		t1 = (float)prc->top / (float)h;
+		t1 = prc->top / (float)h;
-		s2 = (float)prc->right / (float)w;
+		s2 = prc->right / (float)w;
-		t2 = (float)prc->bottom / (float)h;
+		t2 = prc->bottom / (float)h;
 
 		if( width == -1 && height == -1 )
 		{
@@ -354,12 +467,11 @@ static void PIC_DrawGeneric( float x, float y, float width, float height, const
 	}
 
 	// pass scissor test if supposed
-	if( gameui.ds.scissor_test && !PIC_Scissor( &x, &y, &width, &height, &s1, &t1, &s2, &t2 ))
+	if( !CL_Scissor( &gameui.ds.scissor, &x, &y, &width, &height, &s1, &t1, &s2, &t2 ))
 		return;
 
-	PicAdjustSize( &x, &y, &width, &height );
+	ref.dllFuncs.R_DrawStretchPic( x, y, width, height, s1, t1, s2, t2, gameui.ds.gl_texturenum );
-	R_DrawStretchPic( x, y, width, height, s1, t1, s2, t2, gameui.ds.gl_texturenum );
+	ref.dllFuncs.Color4ub( 255, 255, 255, 255 );
-	pglColor4ub( 255, 255, 255, 255 );
 }
 
 /*
@@ -374,13 +486,13 @@ pfnPIC_Load
 
 =========
 */
-static HIMAGE pfnPIC_Load( const char *szPicName, const byte *image_buf, long image_size, long flags )
+static HIMAGE GAME_EXPORT pfnPIC_Load( const char *szPicName, const byte *image_buf, int image_size, int flags )
 {
 	HIMAGE	tx;
 
 	if( !COM_CheckString( szPicName ))
 	{
-		Con_Reportf( S_ERROR "CL_LoadImage: bad name!\n" );
+		Con_Reportf( S_ERROR "CL_LoadImage: refusing to load image with empty name\n" );
 		return 0;
 	}
 
@@ -388,7 +500,7 @@ static HIMAGE pfnPIC_Load( const char *szPicName, const byte *image_buf, long im
 	SetBits( flags, TF_IMAGE );
 
 	Image_SetForceFlags( IL_LOAD_DECAL ); // allow decal images for menu
-	tx = GL_LoadTexture( szPicName, image_buf, image_size, flags );
+	tx = ref.dllFuncs.GL_LoadTexture( szPicName, image_buf, image_size, flags );
 	Image_ClearForceFlags();
 
 	return tx;
@@ -400,7 +512,7 @@ pfnPIC_Width
 
 =========
 */
-static int pfnPIC_Width( HIMAGE hPic )
+static int GAME_EXPORT pfnPIC_Width( HIMAGE hPic )
 {
 	int	picWidth;
 
@@ -415,7 +527,7 @@ pfnPIC_Height
 
 =========
 */
-static int pfnPIC_Height( HIMAGE hPic )
+static int GAME_EXPORT pfnPIC_Height( HIMAGE hPic )
 {
 	int	picHeight;
 
@@ -430,14 +542,14 @@ pfnPIC_Set
 
 =========
 */
-void pfnPIC_Set( HIMAGE hPic, int r, int g, int b, int a )
+void GAME_EXPORT pfnPIC_Set( HIMAGE hPic, int r, int g, int b, int a )
 {
 	gameui.ds.gl_texturenum = hPic;
 	r = bound( 0, r, 255 );
 	g = bound( 0, g, 255 );
 	b = bound( 0, b, 255 );
 	a = bound( 0, a, 255 );
-	pglColor4ub( r, g, b, a );
+	ref.dllFuncs.Color4ub( r, g, b, a );
 }
 
 /*
@@ -446,9 +558,9 @@ pfnPIC_Draw
 
 =========
 */
-void pfnPIC_Draw( int x, int y, int width, int height, const wrect_t *prc )
+void GAME_EXPORT pfnPIC_Draw( int x, int y, int width, int height, const wrect_t *prc )
 {
-	GL_SetRenderMode( kRenderNormal );
+	ref.dllFuncs.GL_SetRenderMode( kRenderNormal );
 	PIC_DrawGeneric( x, y, width, height, prc );
 }
 
@@ -458,9 +570,9 @@ pfnPIC_DrawTrans
 
 =========
 */
-void pfnPIC_DrawTrans( int x, int y, int width, int height, const wrect_t *prc )
+void GAME_EXPORT pfnPIC_DrawTrans( int x, int y, int width, int height, const wrect_t *prc )
 {
-	GL_SetRenderMode( kRenderTransTexture );
+	ref.dllFuncs.GL_SetRenderMode( kRenderTransTexture );
 	PIC_DrawGeneric( x, y, width, height, prc );
 }
 
@@ -470,9 +582,9 @@ pfnPIC_DrawHoles
 
 =========
 */
-void pfnPIC_DrawHoles( int x, int y, int width, int height, const wrect_t *prc )
+void GAME_EXPORT pfnPIC_DrawHoles( int x, int y, int width, int height, const wrect_t *prc )
 {
-	GL_SetRenderMode( kRenderTransAlpha );
+	ref.dllFuncs.GL_SetRenderMode( kRenderTransAlpha );
 	PIC_DrawGeneric( x, y, width, height, prc );
 }
 
@@ -482,9 +594,9 @@ pfnPIC_DrawAdditive
 
 =========
 */
-void pfnPIC_DrawAdditive( int x, int y, int width, int height, const wrect_t *prc )
+void GAME_EXPORT pfnPIC_DrawAdditive( int x, int y, int width, int height, const wrect_t *prc )
 {
-	GL_SetRenderMode( kRenderTransAdd );
+	ref.dllFuncs.GL_SetRenderMode( kRenderTransAdd );
 	PIC_DrawGeneric( x, y, width, height, prc );
 }
 
@@ -494,7 +606,7 @@ pfnPIC_EnableScissor
 
 =========
 */
-static void pfnPIC_EnableScissor( int x, int y, int width, int height )
+static void GAME_EXPORT pfnPIC_EnableScissor( int x, int y, int width, int height )
 {
 	// check bounds
 	x = bound( 0, x, gameui.globals->scrWidth );
@@ -502,11 +614,7 @@ static void pfnPIC_EnableScissor( int x, int y, int width, int height )
 	width = bound( 0, width, gameui.globals->scrWidth - x );
 	height = bound( 0, height, gameui.globals->scrHeight - y );
 
-	gameui.ds.scissor_x = x;
+	CL_EnableScissor( &gameui.ds.scissor, x, y, width, height );
-	gameui.ds.scissor_width = width;
-	gameui.ds.scissor_y = y;
-	gameui.ds.scissor_height = height;
-	gameui.ds.scissor_test = true;
 }
 
 /*
@@ -515,13 +623,9 @@ pfnPIC_DisableScissor
 
 =========
 */
-static void pfnPIC_DisableScissor( void )
+static void GAME_EXPORT pfnPIC_DisableScissor( void )
 {
-	gameui.ds.scissor_x = 0;
+	CL_DisableScissor( &gameui.ds.scissor );
-	gameui.ds.scissor_width = 0;
-	gameui.ds.scissor_y = 0;
-	gameui.ds.scissor_height = 0;
-	gameui.ds.scissor_test = false;
 }
 
 /*
@@ -530,16 +634,27 @@ pfnFillRGBA
 
 =============
 */
-static void pfnFillRGBA( int x, int y, int width, int height, int r, int g, int b, int a )
+static void GAME_EXPORT pfnFillRGBA( int x, int y, int width, int height, int r, int g, int b, int a )
 {
 	r = bound( 0, r, 255 );
 	g = bound( 0, g, 255 );
 	b = bound( 0, b, 255 );
 	a = bound( 0, a, 255 );
-	pglColor4ub( r, g, b, a );
+	ref.dllFuncs.Color4ub( r, g, b, a );
-	GL_SetRenderMode( kRenderTransTexture );
+	ref.dllFuncs.GL_SetRenderMode( kRenderTransTexture );
-	R_DrawStretchPic( x, y, width, height, 0, 0, 1, 1, tr.whiteTexture );
+	ref.dllFuncs.R_DrawStretchPic( x, y, width, height, 0, 0, 1, 1, R_GetBuiltinTexture( REF_WHITE_TEXTURE ) );
-	pglColor4ub( 255, 255, 255, 255 );
+	ref.dllFuncs.Color4ub( 255, 255, 255, 255 );
+}
+
+/*
+=============
+pfnCvar_RegisterVariable
+
+=============
+*/
+static cvar_t *GAME_EXPORT pfnCvar_RegisterGameUIVariable( const char *szName, const char *szValue, int flags )
+{
+	return (cvar_t *)Cvar_Get( szName, szValue, flags|FCVAR_GAMEUIDLL, Cvar_BuildAutoDescription( szName, flags|FCVAR_GAMEUIDLL ));
 }
 
 /*
@@ -548,7 +663,7 @@ pfnClientCmd
 
 =============
 */
-static void pfnClientCmd( int exec_now, const char *szCmdString )
+static void GAME_EXPORT pfnClientCmd( int exec_now, const char *szCmdString )
 {
 	if( !szCmdString || !szCmdString[0] )
 		return;
@@ -566,7 +681,7 @@ pfnPlaySound
 
 =============
 */
-static void pfnPlaySound( const char *szSound )
+static void GAME_EXPORT pfnPlaySound( const char *szSound )
 {
 	if( !COM_CheckString( szSound )) return;
 	S_StartLocalSound( szSound, VOL_NORM, false );
@@ -579,7 +694,7 @@ pfnDrawCharacter
 quakefont draw character
 =============
 */
-static void pfnDrawCharacter( int ix, int iy, int iwidth, int iheight, int ch, int ulRGBA, HIMAGE hFont )
+static void GAME_EXPORT pfnDrawCharacter( int ix, int iy, int iwidth, int iheight, int ch, int ulRGBA, HIMAGE hFont )
 {
 	rgba_t	color;
 	float	row, col, size;
@@ -597,7 +712,7 @@ static void pfnDrawCharacter( int ix, int iy, int iwidth, int iheight, int ch, i
 	color[0] = (ulRGBA & 0xFF0000) >> 16;
 	color[1] = (ulRGBA & 0xFF00) >> 8;
 	color[2] = (ulRGBA & 0xFF) >> 0;
-	pglColor4ubv( color );
+	ref.dllFuncs.Color4ub( color[0], color[1], color[2], color[3] );
 
 	col = (ch & 15) * 0.0625f + (0.5f / 256.0f);
 	row = (ch >> 4) * 0.0625f + (0.5f / 256.0f);
@@ -609,12 +724,12 @@ static void pfnDrawCharacter( int ix, int iy, int iwidth, int iheight, int ch, i
 	t2 = t1 + size;
 
 	// pass scissor test if supposed
-	if( gameui.ds.scissor_test && !PIC_Scissor( &x, &y, &width, &height, &s1, &t1, &s2, &t2 ))
+	if( !CL_Scissor( &gameui.ds.scissor, &x, &y, &width, &height, &s1, &t1, &s2, &t2 ))
 		return;
 
-	GL_SetRenderMode( kRenderTransTexture );
+	ref.dllFuncs.GL_SetRenderMode( kRenderTransTexture );
-	R_DrawStretchPic( x, y, width, height, s1, t1, s2, t2, hFont );
+	ref.dllFuncs.R_DrawStretchPic( x, y, width, height, s1, t1, s2, t2, hFont );
-	pglColor4ub( 255, 255, 255, 255 );
+	ref.dllFuncs.Color4ub( 255, 255, 255, 255 );
 }
 
 /*
@@ -624,7 +739,7 @@ UI_DrawConsoleString
 drawing string like a console string
 =============
 */
-static int UI_DrawConsoleString( int x, int y, const char *string )
+static int GAME_EXPORT UI_DrawConsoleString( int x, int y, const char *string )
 {
 	int	drawLen;
 
@@ -642,7 +757,7 @@ pfnDrawSetTextColor
 set color for anything
 =============
 */
-static void UI_DrawSetTextColor( int r, int g, int b, int alpha )
+static void GAME_EXPORT UI_DrawSetTextColor( int r, int g, int b, int alpha )
 {
 	// bound color and convert to byte
 	gameui.ds.textColor[0] = r;
@@ -658,7 +773,7 @@ pfnGetPlayerModel
 for drawing playermodel previews
 ====================
 */
-static cl_entity_t* pfnGetPlayerModel( void )
+static cl_entity_t* GAME_EXPORT pfnGetPlayerModel( void )
 {
 	return &gameui.playermodel;
 }
@@ -670,7 +785,7 @@ pfnSetPlayerModel
 for drawing playermodel previews
 ====================
 */
-static void pfnSetPlayerModel( cl_entity_t *ent, const char *path )
+static void GAME_EXPORT pfnSetPlayerModel( cl_entity_t *ent, const char *path )
 {
 	ent->model = Mod_ForName( path, false, false );
 	ent->curstate.modelindex = MAX_MODELS; // unreachable index
@@ -683,10 +798,10 @@ pfnClearScene
 for drawing playermodel previews
 ====================
 */
-static void pfnClearScene( void )
+static void GAME_EXPORT pfnClearScene( void )
 {
-	R_PushScene();
+	ref.dllFuncs.R_PushScene();
-	R_ClearScene();
+	ref.dllFuncs.R_ClearScene();
 }
 
 /*
@@ -696,19 +811,23 @@ pfnRenderScene
 for drawing playermodel previews
 ====================
 */
-static void pfnRenderScene( const ref_viewpass_t *rvp )
+static void GAME_EXPORT pfnRenderScene( const ref_viewpass_t *rvp )
 {
+	ref_viewpass_t copy;
+
 	// to avoid division by zero
 	if( !rvp || rvp->fov_x <= 0.0f || rvp->fov_y <= 0.0f )
 		return;
 
-	// don't allow special modes from menu
+	copy = *rvp;
-	((ref_viewpass_t *)&rvp)->flags = 0;
 
-	R_Set2DMode( false );
+	// don't allow special modes from menu
-	R_RenderFrame( rvp );
+	copy.flags = 0;
-	R_Set2DMode( true );
+
-	R_PopScene();
+	ref.dllFuncs.R_Set2DMode( false );
+	GL_RenderFrame( &copy );
+	ref.dllFuncs.R_Set2DMode( true );
+	ref.dllFuncs.R_PopScene();
 }
 
 /*
@@ -718,9 +837,9 @@ pfnAddEntity
 adding player model into visible list
 ====================
 */
-static int pfnAddEntity( int entityType, cl_entity_t *ent )
+static int GAME_EXPORT pfnAddEntity( int entityType, cl_entity_t *ent )
 {
-	if( !R_AddEntity( ent, entityType ))
+	if( !ref.dllFuncs.R_AddEntity( ent, entityType ))
 		return false;
 	return true;
 }
@@ -732,9 +851,9 @@ pfnClientJoin
 send client connect
 ====================
 */
-static void pfnClientJoin( const netadr_t adr )
+static void GAME_EXPORT pfnClientJoin( const netadr_t adr )
 {
-	Cbuf_AddText( va( "connect %s\n", NET_AdrToString( adr )));
+	Cbuf_AddTextf( "connect %s\n", NET_AdrToString( adr ));
 }
 
 /*
@@ -744,7 +863,7 @@ pfnKeyGetOverstrikeMode
 get global key overstrike state
 ====================
 */
-static int pfnKeyGetOverstrikeMode( void )
+static int GAME_EXPORT pfnKeyGetOverstrikeMode( void )
 {
 	return host.key_overstrike;
 }
@@ -756,7 +875,7 @@ pfnKeySetOverstrikeMode
 set global key overstrike mode
 ====================
 */
-static void pfnKeySetOverstrikeMode( int fActive )
+static void GAME_EXPORT pfnKeySetOverstrikeMode( int fActive )
 {
 	host.key_overstrike = fActive;
 }
@@ -792,7 +911,7 @@ pfnMemFree
 
 =========
 */
-static void pfnMemFree( void *mem, const char *filename, const int fileline )
+static void GAME_EXPORT pfnMemFree( void *mem, const char *filename, const int fileline )
 {
 	_Mem_Free( mem, filename, fileline );
 }
@@ -803,7 +922,7 @@ pfnGetGameInfo
 
 =========
 */
-static int pfnGetGameInfo( GAMEINFO *pgameinfo )
+static int GAME_EXPORT pfnGetGameInfo( GAMEINFO *pgameinfo )
 {
 	if( !pgameinfo ) return 0;
 
@@ -817,9 +936,9 @@ pfnGetGamesList
 
 =========
 */
-static GAMEINFO **pfnGetGamesList( int *numGames )
+static GAMEINFO ** GAME_EXPORT pfnGetGamesList( int *numGames )
 {
-	if( numGames ) *numGames = SI.numgames;
+	if( numGames ) *numGames = FI->numgames;
 	return gameui.modsInfo;
 }
 
@@ -830,7 +949,7 @@ pfnGetFilesList
 release prev search on a next call
 =========
 */
-static char **pfnGetFilesList( const char *pattern, int *numFiles, int gamedironly )
+static char ** GAME_EXPORT pfnGetFilesList( const char *pattern, int *numFiles, int gamedironly )
 {
 	static search_t	*t = NULL;
 
@@ -865,18 +984,23 @@ pfnCheckGameDll
 
 =========
 */
-int pfnCheckGameDll( void )
+int GAME_EXPORT pfnCheckGameDll( void )
 {
-	void	*hInst;
+#ifdef XASH_INTERNAL_GAMELIBS
-
-	if( SV_Initialized( )) return true;
-
-	if(( hInst = COM_LoadLibrary( GI->game_dll, true, false )) != NULL )
-	{
-		COM_FreeLibrary( hInst );
 	return true;
-	}
+#else
+	string dllpath;
+
+	if( svgame.hInstance )
+		return true;
+
+	COM_GetCommonLibraryPath( LIBRARY_SERVER, dllpath, sizeof( dllpath ));
+
+	if( FS_FileExists( dllpath, false ))
+		return true;
+
 	return false;
+#endif
 }
 
 /*
@@ -885,12 +1009,9 @@ pfnChangeInstance
 
 =========
 */
-static void pfnChangeInstance( const char *newInstance, const char *szFinalMessage )
+static void GAME_EXPORT pfnChangeInstance( const char *newInstance, const char *szFinalMessage )
 {
-	if( !szFinalMessage ) szFinalMessage = "";
+	Con_Reportf( S_ERROR "ChangeInstance menu call is deprecated!\n" );
-	if( !newInstance || !*newInstance ) return;
-
-	Host_NewInstance( newInstance, szFinalMessage );
 }
 
 /*
@@ -899,10 +1020,10 @@ pfnHostEndGame
 
 =========
 */
-static void pfnHostEndGame( const char *szFinalMessage )
+static void GAME_EXPORT pfnHostEndGame( const char *szFinalMessage )
 {
 	if( !szFinalMessage ) szFinalMessage = "";
-	Host_EndGame( false, szFinalMessage );
+	Host_EndGame( false, "%s", szFinalMessage );
 }
 
 /*
@@ -911,11 +1032,66 @@ pfnStartBackgroundTrack
 
 =========
 */
-static void pfnStartBackgroundTrack( const char *introTrack, const char *mainTrack )
+static void GAME_EXPORT pfnStartBackgroundTrack( const char *introTrack, const char *mainTrack )
 {
 	S_StartBackgroundTrack( introTrack, mainTrack, 0, false );
 }
 
+static void GAME_EXPORT GL_ProcessTexture( int texnum, float gamma, int topColor, int bottomColor )
+{
+	ref.dllFuncs.GL_ProcessTexture( texnum, gamma, topColor, bottomColor );
+}
+
+
+/*
+=================
+UI_ShellExecute
+=================
+*/
+static void GAME_EXPORT UI_ShellExecute( const char *path, const char *parms, int shouldExit )
+{
+	Platform_ShellExecute( path, parms );
+
+	if( shouldExit )
+		Sys_Quit();
+}
+
+/*
+==============
+pfnParseFile
+
+legacy wrapper
+==============
+*/
+static char *pfnParseFile( char *buf, char *token )
+{
+	return COM_ParseFile( buf, token, INT_MAX );
+}
+
+/*
+=============
+pfnFileExists
+
+legacy wrapper
+=============
+*/
+static int pfnFileExists( const char *path, int gamedironly )
+{
+	return FS_FileExists( path, gamedironly );
+}
+
+/*
+=============
+pfnDelete
+
+legacy wrapper
+=============
+*/
+static int pfnDelete( const char *path )
+{
+	return FS_Delete( path );
+}
+
 // engine callbacks
 static ui_enginefuncs_t gEngfuncs =
 {
@@ -962,13 +1138,13 @@ static ui_enginefuncs_t gEngfuncs =
 	pfnRenderScene,
 	pfnAddEntity,
 	Host_Error,
-	FS_FileExists,
+	pfnFileExists,
 	pfnGetGameDir,
 	Cmd_CheckMapsList,
 	CL_Active,
 	pfnClientJoin,
 	COM_LoadFileForMe,
-	COM_ParseFile,
+	pfnParseFile,
 	COM_FreeFile,
 	Key_ClearStates,
 	Key_SetKeyDest,
@@ -988,7 +1164,7 @@ static ui_enginefuncs_t gEngfuncs =
 	CL_GetDemoComment,
 	pfnCheckGameDll,
 	pfnGetClipboardData,
-	Sys_ShellExecute,
+	UI_ShellExecute,
 	Host_WriteServerConfig,
 	pfnChangeInstance,
 	pfnStartBackgroundTrack,
@@ -1000,8 +1176,45 @@ static ui_enginefuncs_t gEngfuncs =
 	GL_ProcessTexture,
 	COM_CompareFileTime,
 	VID_GetModeString,
-	COM_SaveFile,
+	(void*)COM_SaveFile,
-	FS_Delete,
+	pfnDelete
+};
+
+static void pfnEnableTextInput( int enable )
+{
+	Key_EnableTextInput( enable, false );
+}
+
+static int pfnGetRenderers( unsigned int num, char *shortName, size_t size1, char *readableName, size_t size2 )
+{
+	if( num >= ref.numRenderers )
+		return 0;
+
+	if( shortName && size1 )
+		Q_strncpy( shortName, ref.shortNames[num], size1 );
+
+	if( readableName && size2 )
+		Q_strncpy( readableName, ref.readableNames[num], size2 );
+
+	return 1;
+}
+
+static char *pfnParseFileSafe( char *data, char *buf, const int size, unsigned int flags, int *len )
+{
+	return COM_ParseFileSafe( data, buf, size, flags, len, NULL );
+}
+
+static ui_extendedfuncs_t gExtendedfuncs =
+{
+	pfnEnableTextInput,
+	Con_UtfProcessChar,
+	Con_UtfMoveLeft,
+	Con_UtfMoveRight,
+	pfnGetRenderers,
+	Sys_DoubleTime,
+	pfnParseFileSafe,
+	NET_AdrToString,
+	NET_CompareAdrSort,
 };
 
 void UI_UnloadProgs( void )
@@ -1013,18 +1226,23 @@ void UI_UnloadProgs( void )
 
 	Cvar_FullSet( "host_gameuiloaded", "0", FCVAR_READ_ONLY );
 
+	Cvar_Unlink( FCVAR_GAMEUIDLL );
+	Cmd_Unlink( CMD_GAMEUIDLL );
+
 	COM_FreeLibrary( gameui.hInstance );
 	Mem_FreePool( &gameui.mempool );
 	memset( &gameui, 0, sizeof( gameui ));
-
-	Cvar_Unlink( FCVAR_GAMEUIDLL );
-	Cmd_Unlink( CMD_GAMEUIDLL );
 }
 
 qboolean UI_LoadProgs( void )
 {
 	static ui_enginefuncs_t	gpEngfuncs;
+	static ui_extendedfuncs_t gpExtendedfuncs;
 	static ui_globalvars_t	gpGlobals;
+	UIEXTENEDEDAPI GetExtAPI;
+	UITEXTAPI	GiveTextApi;
+	MENUAPI	GetMenuAPI;
+	string dllpath;
 	int			i;
 
 	if( gameui.hInstance ) UI_UnloadProgs();
@@ -1032,11 +1250,26 @@ qboolean UI_LoadProgs( void )
 	// setup globals
 	gameui.globals = &gpGlobals;
 
-	if(( gameui.hInstance = COM_LoadLibrary( va( "%s/menu.dll", GI->dll_path ), false, false )) == NULL )
+	COM_GetCommonLibraryPath( LIBRARY_GAMEUI, dllpath, sizeof( dllpath ));
+
+	if(!( gameui.hInstance = COM_LoadLibrary( dllpath, false, false )))
 	{
-		if(( gameui.hInstance = COM_LoadLibrary( "menu.dll", false, true )) == NULL )
+		string path = OS_LIB_PREFIX "menu." OS_LIB_EXT;
+
+		FS_AllowDirectPaths( true );
+
+		// no use to load it from engine directory, as library loader
+		// that implements internal gamelibs already knows how to load it
+#ifndef XASH_INTERNAL_GAMELIBS
+		if(!( gameui.hInstance = COM_LoadLibrary( path, false, true )))
+#endif
+		{
+			FS_AllowDirectPaths( false );
 			return false;
 		}
+	}
+
+	FS_AllowDirectPaths( false );
 
 	if(( GetMenuAPI = (MENUAPI)COM_GetProcAddress( gameui.hInstance, "GetMenuAPI" )) == NULL )
 	{
@@ -1046,6 +1279,9 @@ qboolean UI_LoadProgs( void )
 		return false;
 	}
 
+
+	gameui.use_text_api = false;
+
 	// make local copy of engfuncs to prevent overwrite it with user dll
 	memcpy( &gpEngfuncs, &gEngfuncs, sizeof( gpEngfuncs ));
 
@@ -1060,19 +1296,54 @@ qboolean UI_LoadProgs( void )
 		return false;
 	}
 
+	// make local copy of engfuncs to prevent overwrite it with user dll
+	memcpy( &gpExtendedfuncs, &gExtendedfuncs, sizeof( gExtendedfuncs ));
+	memset( &gameui.dllFuncs2, 0, sizeof( gameui.dllFuncs2 ));
+
+	// try to initialize new extended API
+	if( ( GetExtAPI = (UIEXTENEDEDAPI)COM_GetProcAddress( gameui.hInstance, "GetExtAPI" ) ) )
+	{
+		Con_Reportf( "UI_LoadProgs: extended Menu API found\n" );
+		if( GetExtAPI( MENU_EXTENDED_API_VERSION, &gameui.dllFuncs2, &gpExtendedfuncs ) )
+		{
+			Con_Reportf( "UI_LoadProgs: extended Menu API initialized\n" );
+			gameui.use_text_api = true;
+		}
+	}
+	else // otherwise, fallback to old and deprecated extensions
+	{
+		if( ( GiveTextApi = (UITEXTAPI)COM_GetProcAddress( gameui.hInstance, "GiveTextAPI" ) ) )
+		{
+			Con_Reportf( "UI_LoadProgs: extended text API found\n" );
+			Con_Reportf( S_WARN "Text API is deprecated! If you are mod developer, consider moving to Extended Menu API!\n" );
+			if( GiveTextApi( &gpExtendedfuncs ) ) // they are binary compatible, so we can just pass extended funcs API to menu
+			{
+				Con_Reportf( "UI_LoadProgs: extended text API initialized\n" );
+				gameui.use_text_api = true;
+			}
+		}
+
+		gameui.dllFuncs2.pfnAddTouchButtonToList = (ADDTOUCHBUTTONTOLIST)COM_GetProcAddress( gameui.hInstance, "AddTouchButtonToList" );
+		if( gameui.dllFuncs2.pfnAddTouchButtonToList )
+		{
+			Con_Reportf( "UI_LoadProgs: AddTouchButtonToList call found\n" );
+			Con_Reportf( S_WARN "AddTouchButtonToList is deprecated! If you are mod developer, consider moving to Extended Menu API!\n" );
+		}
+	}
+
 	Cvar_FullSet( "host_gameuiloaded", "1", FCVAR_READ_ONLY );
 
 	// setup gameinfo
-	for( i = 0; i < SI.numgames; i++ )
+	for( i = 0; i < FI->numgames; i++ )
 	{
 		gameui.modsInfo[i] = Mem_Calloc( gameui.mempool, sizeof( GAMEINFO ));
-		UI_ConvertGameInfo( gameui.modsInfo[i], SI.games[i] );
+		UI_ConvertGameInfo( gameui.modsInfo[i], FI->games[i] );
 	}
 
-	UI_ConvertGameInfo( &gameui.gameInfo, SI.GameInfo ); // current gameinfo
+	UI_ConvertGameInfo( &gameui.gameInfo, FI->GameInfo ); // current gameinfo
 
 	// setup globals
-	gameui.globals->allow_console = host.allow_console;
+	gameui.globals->developer = host.allow_console;
 
 	// initialize game
 	gameui.dllFuncs.pfnInit();

engine/client/cl_mobile.c

@@ -0,0 +1,145 @@
+/*
+cl_mobile.c - common mobile interface
+Copyright (C) 2015 a1batross
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+*/
+
+#include "common.h"
+#include "client.h"
+#include "mobility_int.h"
+#include "library.h"
+#include "input.h"
+#include "platform/platform.h"
+
+static mobile_engfuncs_t *gMobileEngfuncs;
+
+static CVAR_DEFINE_AUTO( vibration_length, "1.0", FCVAR_ARCHIVE | FCVAR_PRIVILEGED, "vibration length" );
+static CVAR_DEFINE_AUTO( vibration_enable, "1", FCVAR_ARCHIVE | FCVAR_PRIVILEGED, "enable vibration" );
+
+static cl_font_t g_scaled_font;
+static float g_font_scale;
+
+static void pfnVibrate( float life, char flags )
+{
+	if( !vibration_enable.value )
+		return;
+
+	if( life < 0.0f )
+	{
+		Con_Reportf( S_WARN "Negative vibrate time: %f\n", life );
+		return;
+	}
+
+	//Con_Reportf( "Vibrate: %f %d\n", life, flags );
+
+	// here goes platform-specific backends
+	Platform_Vibrate( life * vibration_length.value, flags );
+}
+
+static void Vibrate_f( void )
+{
+	if( Cmd_Argc() != 2 )
+	{
+		Msg( S_USAGE "vibrate <time>\n" );
+		return;
+	}
+
+	pfnVibrate( Q_atof( Cmd_Argv(1) ), VIBRATE_NORMAL );
+}
+
+static void pfnEnableTextInput( int enable )
+{
+	Key_EnableTextInput( enable, false );
+}
+
+static int pfnDrawScaledCharacter( int x, int y, int number, int r, int g, int b, float scale )
+{
+	// this call is very ineffective and possibly broken!
+	rgba_t color = { r, g, b, 255 };
+	int flags = FONT_DRAW_HUD;
+
+	if( hud_utf8.value )
+		SetBits( flags, FONT_DRAW_UTF8 );
+
+	if( fabs( g_font_scale - scale ) > 0.1f ||
+		g_scaled_font.hFontTexture != cls.creditsFont.hFontTexture )
+	{
+		int i;
+
+		g_scaled_font = cls.creditsFont;
+		g_scaled_font.scale *= scale;
+		g_scaled_font.charHeight *= scale;
+		for( i = 0; i < ARRAYSIZE( g_scaled_font.charWidths ); i++ )
+			g_scaled_font.charWidths[i] *= scale;
+
+		g_font_scale = scale;
+	}
+
+	return CL_DrawCharacter( x, y, number, color, &g_scaled_font, flags );
+}
+
+static void pfnTouch_HideButtons( const char *name, byte state )
+{
+	Touch_HideButtons( name, state, true );
+}
+
+static void pfnTouch_RemoveButton( const char *name )
+{
+	Touch_RemoveButton( name, true );
+}
+
+static char *pfnParseFileSafe( char *data, char *buf, const int size, unsigned int flags, int *len )
+{
+	return COM_ParseFileSafe( data, buf, size, flags, len, NULL );
+}
+
+static mobile_engfuncs_t gpMobileEngfuncs =
+{
+	MOBILITY_API_VERSION,
+	pfnVibrate,
+	pfnEnableTextInput,
+	Touch_AddClientButton,
+	Touch_AddDefaultButton,
+	pfnTouch_HideButtons,
+	pfnTouch_RemoveButton,
+	Touch_SetClientOnly,
+	Touch_ResetDefaultButtons,
+	pfnDrawScaledCharacter,
+	Sys_Warn,
+	Sys_GetNativeObject,
+	ID_SetCustomClientID,
+	pfnParseFileSafe
+};
+
+qboolean Mobile_Init( void )
+{
+	qboolean success = false;
+	pfnMobilityInterface ExportToClient;
+
+	// find a mobility interface
+	ExportToClient = COM_GetProcAddress( clgame.hInstance, MOBILITY_CLIENT_EXPORT );
+	gMobileEngfuncs = &gpMobileEngfuncs;
+
+	if( ExportToClient && !ExportToClient( gMobileEngfuncs ) )
+		success = true;
+
+	Cmd_AddCommand( "vibrate", (xcommand_t)Vibrate_f, "Vibrate for specified time");
+	Cvar_RegisterVariable( &vibration_length );
+	Cvar_RegisterVariable( &vibration_enable );
+
+	return success;
+}
+
+void Mobile_Shutdown( void )
+{
+	Cmd_RemoveCommand( "vibrate" );
+}

engine/client/cl_netgraph.c

@@ -15,24 +15,30 @@ GNU General Public License for more details.
 
 #include "common.h"
 #include "client.h"
-#include "gl_local.h"
+#include "kbutton.h"
 
+#if XASH_LOW_MEMORY == 0
 #define NET_TIMINGS			1024
+#elif XASH_LOW_MEMORY == 1
+#define NET_TIMINGS			256
+#elif XASH_LOW_MEMORY == 2
+#define NET_TIMINGS			64
+#endif
 #define NET_TIMINGS_MASK		(NET_TIMINGS - 1)
-#define LATENCY_AVG_FRAC		0.5
+#define LATENCY_AVG_FRAC		0.5f
-#define FRAMERATE_AVG_FRAC		0.5
+#define FRAMERATE_AVG_FRAC		0.5f
-#define PACKETLOSS_AVG_FRAC		0.5
+#define PACKETLOSS_AVG_FRAC		0.5f
-#define PACKETCHOKE_AVG_FRAC		0.5
+#define PACKETCHOKE_AVG_FRAC		0.5f
 #define NETGRAPH_LERP_HEIGHT		24
 #define NETGRAPH_NET_COLORS		5
 #define NUM_LATENCY_SAMPLES		8
 
-convar_t	*net_graph;
+CVAR_DEFINE_AUTO( net_graph, "0", FCVAR_ARCHIVE, "draw network usage graph" );
-convar_t	*net_graphpos;
+static CVAR_DEFINE_AUTO( net_graphpos, "1", FCVAR_ARCHIVE, "network usage graph position" );
-convar_t	*net_graphwidth;
+static CVAR_DEFINE_AUTO( net_scale, "5", FCVAR_ARCHIVE, "network usage graph scale level" );
-convar_t	*net_graphheight;
+static CVAR_DEFINE_AUTO( net_graphwidth, "192", FCVAR_ARCHIVE, "network usage graph width" );
-convar_t	*net_graphsolid;
+static CVAR_DEFINE_AUTO( net_graphheight, "64", FCVAR_ARCHIVE, "network usage graph height" );
-convar_t	*net_scale;
+static CVAR_DEFINE_AUTO( net_graphsolid, "1", FCVAR_ARCHIVE, "fill segments in network usage graph" );
 
 static struct packet_latency_t
 {
@@ -75,12 +81,12 @@ NetGraph_FillRGBA shortcut
 */
 static void NetGraph_DrawRect( wrect_t *rect, byte colors[4] )
 {
-	pglColor4ubv( colors );	// color for this quad
+	ref.dllFuncs.Color4ub( colors[0], colors[1], colors[2], colors[3] );	// color for this quad
 
-	pglVertex2f( rect->left, rect->top );
+	ref.dllFuncs.Vertex3f( rect->left, rect->top, 0 );
-	pglVertex2f( rect->left + rect->right, rect->top );
+	ref.dllFuncs.Vertex3f( rect->left + rect->right, rect->top, 0 );
-	pglVertex2f( rect->left + rect->right, rect->top + rect->bottom );
+	ref.dllFuncs.Vertex3f( rect->left + rect->right, rect->top + rect->bottom, 0 );
-	pglVertex2f( rect->left, rect->top + rect->bottom );
+	ref.dllFuncs.Vertex3f( rect->left, rect->top + rect->bottom, 0 );
 }
 
 /*
@@ -90,7 +96,7 @@ NetGraph_AtEdge
 edge detect
 ==========
 */
-qboolean NetGraph_AtEdge( int x, int width )
+static qboolean NetGraph_AtEdge( int x, int width )
 {
 	if( x > 3 )
 	{
@@ -108,7 +114,7 @@ NetGraph_InitColors
 init netgraph colors
 ==========
 */
-void NetGraph_InitColors( void )
+static void NetGraph_InitColors( void )
 {
 	byte	mincolor[2][3];
 	byte	maxcolor[2][3];
@@ -152,6 +158,7 @@ void NetGraph_InitColors( void )
 			f = (float)(i - hfrac) / (float)(NETGRAPH_LERP_HEIGHT - hfrac );
 			VectorMA( mincolor[1], f, dc[1], netcolors[NETGRAPH_NET_COLORS + i] );
 		}
+		netcolors[NETGRAPH_NET_COLORS + i][3] = 255;
 	}
 }
 
@@ -162,7 +169,7 @@ NetGraph_GetFrameData
 get frame data info, like chokes, packet losses, also update graph, packet and cmdinfo
 ==========
 */
-void NetGraph_GetFrameData( float *latency, int *latency_count )
+static void NetGraph_GetFrameData( float *latency, int *latency_count )
 {
 	int		i, choke_count = 0, loss_count = 0;
 	double		newtime = Sys_DoubleTime();
@@ -204,7 +211,7 @@ void NetGraph_GetFrameData( float *latency, int *latency_count )
 		else
 		{
 			int frame_latency = Q_min( 1.0f, f->latency );
-			p->latency = (( frame_latency + 0.1 ) / 1.1 ) * ( net_graphheight->value - NETGRAPH_LERP_HEIGHT - 2 );
+			p->latency = (( frame_latency + 0.1f ) / 1.1f ) * ( net_graphheight.value - NETGRAPH_LERP_HEIGHT - 2 );
 
 			if( i > cls.netchan.incoming_sequence - NUM_LATENCY_SAMPLES )
 			{
@@ -230,12 +237,12 @@ void NetGraph_GetFrameData( float *latency, int *latency_count )
 	}
 
 	// packet loss
-	loss = 100.0 * (float)loss_count / CL_UPDATE_BACKUP;
+	loss = 100.0f * (float)loss_count / CL_UPDATE_BACKUP;
-	packet_loss = PACKETLOSS_AVG_FRAC * packet_loss + ( 1.0 - PACKETLOSS_AVG_FRAC ) * loss;
+	packet_loss = PACKETLOSS_AVG_FRAC * packet_loss + ( 1.0f - PACKETLOSS_AVG_FRAC ) * loss;
 
 	// packet choke
-	choke = 100.0 * (float)choke_count / CL_UPDATE_BACKUP;
+	choke = 100.0f * (float)choke_count / CL_UPDATE_BACKUP;
-	packet_choke = PACKETCHOKE_AVG_FRAC * packet_choke + ( 1.0 - PACKETCHOKE_AVG_FRAC ) * choke;
+	packet_choke = PACKETCHOKE_AVG_FRAC * packet_choke + ( 1.0f - PACKETCHOKE_AVG_FRAC ) * choke;
 }
 
 /*
@@ -244,7 +251,7 @@ NetGraph_DrawTimes
 
 ===========
 */
-void NetGraph_DrawTimes( wrect_t rect, int x, int w )
+static void NetGraph_DrawTimes( wrect_t rect, int x, int w )
 {
 	int	i, j, extrap_point = NETGRAPH_LERP_HEIGHT / 3, a, h;
 	rgba_t	colors = { 0.9 * 255, 0.9 * 255, 0.7 * 255, 255 };
@@ -253,7 +260,7 @@ void NetGraph_DrawTimes( wrect_t rect, int x, int w )
 	for( a = 0; a < w; a++ )
 	{
 		i = ( cls.netchan.outgoing_sequence - a ) & NET_TIMINGS_MASK;
-		h = ( netstat_cmdinfo[i].cmd_lerp / 3.0f ) * NETGRAPH_LERP_HEIGHT;
+		h = Q_min(( netstat_cmdinfo[i].cmd_lerp / 3.0f ) * NETGRAPH_LERP_HEIGHT, net_graphheight.value * 0.7f);
 
 		fill.left = x + w - a - 1;
 		fill.right = fill.bottom = 1;
@@ -266,7 +273,7 @@ void NetGraph_DrawTimes( wrect_t rect, int x, int w )
 			h -= extrap_point;
 			fill.top -= extrap_point;
 
-			if( !net_graphsolid->value )
+			if( !net_graphsolid.value )
 			{
 				fill.top -= (h - 1);
 				start = (h - 1);
@@ -274,7 +281,10 @@ void NetGraph_DrawTimes( wrect_t rect, int x, int w )
 
 			for( j = start; j < h; j++ )
 			{
-				NetGraph_DrawRect( &fill, netcolors[NETGRAPH_NET_COLORS + j + extrap_point] );
+				int color = NETGRAPH_NET_COLORS + j + extrap_point;
+				color = Q_min( color, ARRAYSIZE( netcolors ) - 1 );
+
+				NetGraph_DrawRect( &fill, netcolors[color] );
 				fill.top--;
 			}
 		}
@@ -285,12 +295,15 @@ void NetGraph_DrawTimes( wrect_t rect, int x, int w )
 			fill.top -= h;
 			h = extrap_point - h;
 
-			if( !net_graphsolid->value )
+			if( !net_graphsolid.value )
 				h = 1;
 
 			for( j = 0; j < h; j++ )
 			{
-				NetGraph_DrawRect( &fill, netcolors[NETGRAPH_NET_COLORS + j + oldh] );
+				int color = NETGRAPH_NET_COLORS + j + oldh;
+				color = Q_min( color, ARRAYSIZE( netcolors ) - 1 );
+
+				NetGraph_DrawRect( &fill, netcolors[color] );
 				fill.top--;
 			}
 		}
@@ -319,9 +332,9 @@ NetGraph_DrawHatches
 
 ===========
 */
-void NetGraph_DrawHatches( int x, int y )
+static void NetGraph_DrawHatches( int x, int y )
 {
-	int	ystep = (int)( 10.0f / net_scale->value );
+	int	ystep = (int)( 10.0f / net_scale.value );
 	byte	colorminor[4] = { 0, 63, 63, 200 };
 	byte	color[4] = { 0, 200, 0, 255 };
 	wrect_t	hatch = { x, 4, y, 1 };
@@ -329,9 +342,9 @@ void NetGraph_DrawHatches( int x, int y )
 
 	ystep = Q_max( ystep, 1 );
 
-	for( starty = hatch.top; hatch.top > 0 && ((starty - hatch.top) * net_scale->value < (maxmsgbytes + 50)); hatch.top -= ystep )
+	for( starty = hatch.top; hatch.top > 0 && ((starty - hatch.top) * net_scale.value < (maxmsgbytes + 50)); hatch.top -= ystep )
 	{
-		if(!((int)((starty - hatch.top) * net_scale->value ) % 50 ))
+		if(!((int)((starty - hatch.top) * net_scale.value ) % 50 ))
 		{
 			NetGraph_DrawRect( &hatch, color );
 		}
@@ -348,40 +361,42 @@ NetGraph_DrawTextFields
 
 ===========
 */
-void NetGraph_DrawTextFields( int x, int y, int w, wrect_t rect, int count, float avg, int packet_loss, int packet_choke )
+static void NetGraph_DrawTextFields( int x, int y, int w, wrect_t rect, int count, float avg, int packet_loss, int packet_choke, int graphtype )
 {
 	static int	lastout;
+	cl_font_t *font = Con_GetFont( 0 );
 	rgba_t		colors = { 0.9 * 255, 0.9 * 255, 0.7 * 255, 255 };
 	int		ptx = Q_max( x + w - NETGRAPH_LERP_HEIGHT - 1, 1 );
 	int		pty = Q_max( rect.top + rect.bottom - NETGRAPH_LERP_HEIGHT - 3, 1 );
 	int		out, i = ( cls.netchan.outgoing_sequence - 1 ) & NET_TIMINGS_MASK;
 	int		j = cls.netchan.incoming_sequence & NET_TIMINGS_MASK;
-	int		last_y = y - net_graphheight->value;
+	int		last_y = y - net_graphheight.value;
 
 	if( count > 0 )
 	{
 		avg = avg / (float)( count - ( host.frametime * FRAMERATE_AVG_FRAC ));
 
-		if( cl_updaterate->value > 0.0f )
+		if( cl_updaterate.value > 0.0f )
-			avg -= 1000.0f / cl_updaterate->value;
+			avg -= 1000.0f / cl_updaterate.value;
 
 		// can't be below zero
-		avg = Q_max( 0.0, avg );
+		avg = Q_max( 0.0f, avg );
 	}
 	else avg = 0.0;
 
 	// move rolling average
-	framerate = FRAMERATE_AVG_FRAC * host.frametime + ( 1.0 - FRAMERATE_AVG_FRAC ) * framerate;
+	framerate = FRAMERATE_AVG_FRAC * host.frametime + ( 1.0f - FRAMERATE_AVG_FRAC ) * framerate;
-	Con_SetFont( 0 );
+
+	ref.dllFuncs.GL_SetRenderMode( font->rendermode );
 
 	if( framerate > 0.0f )
 	{
-		y -= net_graphheight->value;
+		y -= net_graphheight.value;
 
-		Con_DrawString( x, y, va( "%.1f fps" , 1.0f / framerate ), colors );
+		CL_DrawStringf( font, x, y, colors, FONT_DRAW_NORENDERMODE, "%.1f fps" , 1.0f / framerate);
 
 		if( avg > 1.0f )
-			Con_DrawString( x + 75, y, va( "%i ms" , (int)avg ), colors );
+			CL_DrawStringf( font, x + 75, y, colors, FONT_DRAW_NORENDERMODE, "%i ms" , (int)avg );
 
 		y += 15;
 
@@ -389,27 +404,27 @@ void NetGraph_DrawTextFields( int x, int y, int w, wrect_t rect, int count, floa
 		if( !out ) out = lastout;
 		else lastout = out;
 
-		Con_DrawString( x, y, va( "in :  %i %.2f k/s", netstat_graph[j].msgbytes, cls.netchan.flow[FLOW_INCOMING].avgkbytespersec ), colors );
+		CL_DrawStringf( font, x, y, colors, FONT_DRAW_NORENDERMODE,
+			"in :  %i %.2f kb/s", netstat_graph[j].msgbytes, cls.netchan.flow[FLOW_INCOMING].avgkbytespersec );
 		y += 15;
 
-		Con_DrawString( x, y, va( "out:  %i %.2f k/s", out, cls.netchan.flow[FLOW_OUTGOING].avgkbytespersec ), colors );
+		CL_DrawStringf( font, x, y, colors, FONT_DRAW_NORENDERMODE,
+			"out:  %i %.2f kb/s", out, cls.netchan.flow[FLOW_OUTGOING].avgkbytespersec );
 		y += 15;
 
-		if( net_graph->value > 2 )
+		if( graphtype > 2 )
 		{
-			int	loss = (int)(( packet_loss + PACKETLOSS_AVG_FRAC ) - 0.01 );
+			int	loss = (int)(( packet_loss + PACKETLOSS_AVG_FRAC ) - 0.01f );
-			int	choke = (int)(( packet_choke + PACKETCHOKE_AVG_FRAC ) - 0.01 );
+			int	choke = (int)(( packet_choke + PACKETCHOKE_AVG_FRAC ) - 0.01f );
 
-			Con_DrawString( x, y, va( "loss: %i choke: %i", loss, choke ), colors );
+			CL_DrawStringf( font, x, y, colors, FONT_DRAW_NORENDERMODE, "loss: %i choke: %i", loss, choke );
 		}
 	}
 
-	if( net_graph->value < 3 )
+	if( graphtype < 3 )
-		Con_DrawString( ptx, pty, va( "%i/s", (int)cl_cmdrate->value ), colors );
+		CL_DrawStringf( font, ptx, pty, colors, FONT_DRAW_NORENDERMODE, "%i/s", (int)cl_cmdrate.value );
 
-	Con_DrawString( ptx, last_y, va( "%i/s" , (int)cl_updaterate->value ), colors );
+	CL_DrawStringf( font, ptx, last_y, colors, FONT_DRAW_NORENDERMODE, "%i/s" , (int)cl_updaterate.value );
-
-	Con_RestoreFont();
 }
 
 /*
@@ -418,14 +433,14 @@ NetGraph_DrawDataSegment
 
 ===========
 */
-int NetGraph_DrawDataSegment( wrect_t *fill, int bytes, byte r, byte g, byte b, byte a )
+static int NetGraph_DrawDataSegment( wrect_t *fill, int bytes, byte r, byte g, byte b, byte a )
 {
-	float	h = bytes / net_scale->value;
+	float	h = bytes / net_scale.value;
 	byte	colors[4] = { r, g, b, a };
 
 	fill->top -= (int)h;
 
-	if( net_graphsolid->value )
+	if( net_graphsolid.value )
 		fill->bottom = (int)h;
 	else fill->bottom = 1;
 
@@ -445,7 +460,7 @@ NetGraph_ColorForHeight
 color based on packet latency
 ===========
 */
-void NetGraph_ColorForHeight( struct packet_latency_t *packet, byte color[4], int *ping )
+static void NetGraph_ColorForHeight( struct packet_latency_t *packet, byte color[4], int *ping )
 {
 	switch( packet->latency )
 	{
@@ -480,10 +495,10 @@ NetGraph_DrawDataUsage
 
 ===========
 */
-void NetGraph_DrawDataUsage( int x, int y, int w )
+static void NetGraph_DrawDataUsage( int x, int y, int w, int graphtype )
 {
 	int	a, i, h, lastvalidh = 0, ping;
-	int	pingheight = net_graphheight->value - NETGRAPH_LERP_HEIGHT - 2;
+	int	pingheight = net_graphheight.value - NETGRAPH_LERP_HEIGHT - 2;
 	wrect_t	fill = { 0 };
 	byte	color[4];
 
@@ -535,11 +550,11 @@ void NetGraph_DrawDataUsage( int x, int y, int w )
 		if( NetGraph_AtEdge( a, w ))
 			NetGraph_DrawRect( &fill, color );
 
-		if( net_graph->value < 2 )
+		if( graphtype < 2 )
 			continue;
 
 		color[0] = color[1] = color[2] = color[3] = 255;
-		fill.top = y - net_graphheight->value - 1;
+		fill.top = y - net_graphheight.value - 1;
 		fill.bottom = 1;
 
 		if( NetGraph_AtEdge( a, w ))
@@ -574,7 +589,7 @@ void NetGraph_DrawDataUsage( int x, int y, int w )
 		if( !NetGraph_DrawDataSegment( &fill, netstat_graph[i].voicebytes, 255, 255, 255, 255 ))
 			continue;
 
-		fill.top = y - net_graphheight->value - 1;
+		fill.top = y - net_graphheight.value - 1;
 		fill.bottom = 1;
 		fill.top -= 2;
 
@@ -582,8 +597,8 @@ void NetGraph_DrawDataUsage( int x, int y, int w )
 			continue;
 	}
 
-	if( net_graph->value >= 2 )
+	if( graphtype >= 2 )
-		NetGraph_DrawHatches( x, y - net_graphheight->value - 1 );
+		NetGraph_DrawHatches( x, y - net_graphheight.value - 1 );
 }
 
 /*
@@ -592,24 +607,24 @@ NetGraph_GetScreenPos
 
 ===========
 */
-void NetGraph_GetScreenPos( wrect_t *rect, int *w, int *x, int *y )
+static void NetGraph_GetScreenPos( wrect_t *rect, int *w, int *x, int *y )
 {
 	rect->left = rect->top = 0;
-	rect->right = glState.width;
+	rect->right = refState.width;
-	rect->bottom = glState.height;
+	rect->bottom = refState.height;
 
-	*w = Q_min( NET_TIMINGS, net_graphwidth->value );
+	*w = Q_min( NET_TIMINGS, net_graphwidth.value );
 	if( rect->right < *w + 10 )
 		*w = rect->right - 10;
 
 	// detect x and y position
-	switch( (int)net_graphpos->value )
+	switch( (int)net_graphpos.value )
 	{
 	case 1: // right sided
 		*x = rect->left + rect->right - 5 - *w;
 		break;
 	case 2: // center
-		*x = rect->left + ( rect->right - 10 - *w ) / 2;
+		*x = ( rect->left + ( rect->right - 10 - *w )) / 2;
 		break;
 	default: // left sided
 		*x = rect->left + 5;
@@ -631,6 +646,8 @@ void SCR_DrawNetGraph( void )
 	float	avg_ping;
 	int	ping_count;
 	int	w, x, y;
+	kbutton_t *in_graph;
+	int   graphtype;
 
 	if( !host.allow_console )
 		return;
@@ -638,45 +655,54 @@ void SCR_DrawNetGraph( void )
 	if( cls.state != ca_active )
 		return;
 
-	if( !net_graph->value )
+	in_graph = clgame.dllFuncs.KB_Find( "in_graph" );
-		return;
 
-	if( net_scale->value <= 0 )
+	if( in_graph->state & 1 )
+	{
+		graphtype = 2;
+	}
+	else if( net_graph.value != 0.0f )
+	{
+		graphtype = (int)net_graph.value;
+	}
+	else
+	{
+		return;
+	}
+
+	if( net_scale.value <= 0 )
 		Cvar_SetValue( "net_scale", 0.1f );
 
 	NetGraph_GetScreenPos( &rect, &w, &x, &y );
 
 	NetGraph_GetFrameData( &avg_ping, &ping_count );
 
-	NetGraph_DrawTextFields( x, y, w, rect, ping_count, avg_ping, packet_loss, packet_choke );
+	NetGraph_DrawTextFields( x, y, w, rect, ping_count, avg_ping, packet_loss, packet_choke, graphtype );
 
-	if( net_graph->value < 3 )
+	if( graphtype < 3 )
 	{
-		pglEnable( GL_BLEND );
+		ref.dllFuncs.GL_SetRenderMode( kRenderTransColor );
-		pglDisable( GL_TEXTURE_2D );
+		ref.dllFuncs.GL_Bind( XASH_TEXTURE0, R_GetBuiltinTexture( REF_WHITE_TEXTURE ) );
-		pglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
+		ref.dllFuncs.Begin( TRI_QUADS ); // draw all the fills as a long solid sequence of quads for speedup reasons
-		pglBlendFunc( GL_SRC_ALPHA, GL_ONE );
-		pglBegin( GL_QUADS ); // draw all the fills as a long solid sequence of quads for speedup reasons
 
 		// NOTE: fill colors without texture at this point
-		NetGraph_DrawDataUsage( x, y, w );
+		NetGraph_DrawDataUsage( x, y, w, graphtype );
 		NetGraph_DrawTimes( rect, x, w );
 
-		pglEnd();
+		ref.dllFuncs.End();
-		pglColor4ub( 255, 255, 255, 255 );
+		ref.dllFuncs.Color4ub( 255, 255, 255, 255 );
-		pglEnable( GL_TEXTURE_2D );
+		ref.dllFuncs.GL_SetRenderMode( kRenderNormal );
-		pglDisable( GL_BLEND );
 	}
 }
 
 void CL_InitNetgraph( void )
 {
-	net_graph = Cvar_Get( "net_graph", "0", FCVAR_ARCHIVE, "draw network usage graph" );
+	Cvar_RegisterVariable( &net_graph );
-	net_graphpos = Cvar_Get( "net_graphpos", "1", FCVAR_ARCHIVE, "network usage graph position" );
+	Cvar_RegisterVariable( &net_graphpos );
-	net_scale = Cvar_Get( "net_scale", "5", FCVAR_ARCHIVE, "network usage graph scale level" );
+	Cvar_RegisterVariable( &net_scale );
-	net_graphwidth = Cvar_Get( "net_graphwidth", "192", FCVAR_ARCHIVE, "network usage graph width" );
+	Cvar_RegisterVariable( &net_graphwidth );
-	net_graphheight = Cvar_Get( "net_graphheight", "64", FCVAR_ARCHIVE, "network usage graph height" );
+	Cvar_RegisterVariable( &net_graphheight );
-	net_graphsolid = Cvar_Get( "net_graphsolid", "1", FCVAR_ARCHIVE, "fill segments in network usage graph" );
+	Cvar_RegisterVariable( &net_graphsolid );
 	packet_loss = packet_choke = 0.0;
 
 	NetGraph_InitColors();

engine/client/cl_parse.c

@@ -17,14 +17,14 @@ GNU General Public License for more details.
 #include "client.h"
 #include "net_encode.h"
 #include "particledef.h"
-#include "gl_local.h"
 #include "cl_tent.h"
 #include "shake.h"
 #include "hltv.h"
 #include "input.h"
-
+#include "server.h"
+#if XASH_LOW_MEMORY != 2
 int CL_UPDATE_BACKUP = SINGLEPLAYER_BACKUP;
-
+#endif
 /*
 ===============
 CL_UserMsgStub
@@ -93,7 +93,7 @@ void CL_ParseSoundPacket( sizebuf_t *msg )
 		char	sentenceName[32];
 
 		if( FBitSet( flags, SND_SEQUENCE ))
-			Q_snprintf( sentenceName, sizeof( sentenceName ), "!#%i", sound + MAX_SOUNDS );
+			Q_snprintf( sentenceName, sizeof( sentenceName ), "!#%i", sound + MAX_SOUNDS_NONSENTENCE );
 		else Q_snprintf( sentenceName, sizeof( sentenceName ), "!%i", sound );
 
 		handle = S_RegisterSound( sentenceName );
@@ -157,7 +157,7 @@ void CL_ParseRestoreSoundPacket( sizebuf_t *msg )
 		char	sentenceName[32];
 
 		if( flags & SND_SEQUENCE )
-			Q_snprintf( sentenceName, sizeof( sentenceName ), "!%i", sound + MAX_SOUNDS );
+			Q_snprintf( sentenceName, sizeof( sentenceName ), "!%i", sound + MAX_SOUNDS_NONSENTENCE );
 		else Q_snprintf( sentenceName, sizeof( sentenceName ), "!%i", sound );
 
 		handle = S_RegisterSound( sentenceName );
@@ -197,7 +197,7 @@ void CL_ParseServerTime( sizebuf_t *msg )
 
 	dt = cl.time - cl.mtime[0];
 
-	if( fabs( dt ) > cl_clockreset->value )	// 0.1 by default
+	if( fabs( dt ) > cl_clockreset.value )	// 0.1 by default
 	{
 		cl.time = cl.mtime[0];
 		cl.timedelta = 0.0f;
@@ -250,7 +250,7 @@ void CL_ParseMovevars( sizebuf_t *msg )
 
 	// update sky if changed
 	if( Q_strcmp( clgame.oldmovevars.skyName, clgame.movevars.skyName ) && cl.video_prepped )
-		R_SetupSky( clgame.movevars.skyName );
+		ref.dllFuncs.R_SetupSky( clgame.movevars.skyName );
 
 	memcpy( &clgame.oldmovevars, &clgame.movevars, sizeof( movevars_t ));
 	clgame.entities->curstate.scale = clgame.movevars.waveHeight;
@@ -343,7 +343,7 @@ void CL_ParseStaticEntity( sizebuf_t *msg )
 	if( ent->curstate.rendermode == kRenderNormal && ent->model != NULL )
 	{
 		// auto 'solid' faces
-		if( FBitSet( ent->model->flags, MODEL_TRANSPARENT ) && CL_IsQuakeCompatible( ))
+		if( FBitSet( ent->model->flags, MODEL_TRANSPARENT ) && Host_IsQuakeCompatible( ))
 		{
 			ent->curstate.rendermode = kRenderTransAlpha;
 			ent->curstate.renderamt = 255;
@@ -353,6 +353,7 @@ void CL_ParseStaticEntity( sizebuf_t *msg )
 	R_AddEfrags( ent );	// add link
 }
 
+
 /*
 ==================
 CL_WeaponAnim
@@ -360,7 +361,7 @@ CL_WeaponAnim
 Set new weapon animation
 ==================
 */
-void CL_WeaponAnim( int iAnim, int body )
+void GAME_EXPORT CL_WeaponAnim( int iAnim, int body )
 {
 	cl_entity_t	*view = &clgame.viewent;
 
@@ -484,6 +485,8 @@ void CL_BatchResourceRequest( qboolean initialize )
 		switch( p->type )
 		{
 		case t_sound:
+		case t_model:
+		case t_eventscript:
 			if( !CL_CheckFile( &msg, p ))
 				break;
 			CL_MoveToOnHandList( p );
@@ -491,21 +494,13 @@ void CL_BatchResourceRequest( qboolean initialize )
 		case t_skin:
 			CL_MoveToOnHandList( p );
 			break;
-		case t_model:
-			if( !CL_CheckFile( &msg, p ))
-				break;
-			CL_MoveToOnHandList( p );
-			break;
 		case t_decal:
 			if( !HPAK_GetDataPointer( CUSTOM_RES_PATH, p, NULL, NULL ))
 			{
 				if( !FBitSet( p->ucFlags, RES_REQUESTED ))
 				{
-					string	filename;
-
-					Q_snprintf( filename, sizeof( filename ), "!MD5%s", MD5_Print( p->rgucMD5_hash ));
 					MSG_BeginClientCmd( &msg, clc_stringcmd );
-					MSG_WriteString( &msg, va( "dlfile %s", filename ));
+					MSG_WriteStringf( &msg, "dlfile !MD5%s", MD5_Print( p->rgucMD5_hash ));;
 					SetBits( p->ucFlags, RES_REQUESTED );
 				}
 				break;
@@ -523,17 +518,19 @@ void CL_BatchResourceRequest( qboolean initialize )
 				break;
 			CL_MoveToOnHandList( p );
 			break;
-		case t_eventscript:
+		case t_world:
-			if( !CL_CheckFile( &msg, p ))
+			ASSERT( 0 );
-				break;
-			CL_MoveToOnHandList( p );
 			break;
 		}
 	}
 
 	if( cls.state != ca_disconnected )
 	{
-		if( !MSG_GetNumBytesWritten( &msg ) && CL_PrecacheResources( ))
+		if( !cl.downloadUrl[0] && !MSG_GetNumBytesWritten( &msg ) && CL_PrecacheResources( ))
+		{
+			CL_RegisterResources( &msg );
+		}
+		if( cl.downloadUrl[0] && host.downloadcount == 0 &&  CL_PrecacheResources( ) )
 		{
 			CL_RegisterResources( &msg );
 		}
@@ -547,23 +544,20 @@ int CL_EstimateNeededResources( void )
 {
 	resource_t	*p;
 	int		nTotalSize = 0;
-	int		nSize;
 
 	for( p = cl.resourcesneeded.pNext; p != &cl.resourcesneeded; p = p->pNext )
 	{
 		switch( p->type )
 		{
 		case t_sound:
-			nSize = FS_FileSize( va( "%s%s", DEFAULT_SOUNDPATH, p->szFileName ), false );
+			if( p->szFileName[0] != '*' && !FS_FileExists( va( DEFAULT_SOUNDPATH "%s", p->szFileName ), false ) )
-			if( p->szFileName[0] != '*' && nSize == -1 )
 			{
 				SetBits( p->ucFlags, RES_WASMISSING );
 				nTotalSize += p->nDownloadSize;
 			}
 			break;
 		case t_model:
-			nSize = FS_FileSize( p->szFileName, false );
+			if( p->szFileName[0] != '*' && !FS_FileExists( p->szFileName, false ) )
-			if( p->szFileName[0] != '*' && nSize == -1 )
 			{
 				SetBits( p->ucFlags, RES_WASMISSING );
 				nTotalSize += p->nDownloadSize;
@@ -572,8 +566,7 @@ int CL_EstimateNeededResources( void )
 		case t_skin:
 		case t_generic:
 		case t_eventscript:
-			nSize = FS_FileSize( p->szFileName, false );
+			if( !FS_FileExists( p->szFileName, false ) )
-			if( nSize == -1 )
 			{
 				SetBits( p->ucFlags, RES_WASMISSING );
 				nTotalSize += p->nDownloadSize;
@@ -586,13 +579,16 @@ int CL_EstimateNeededResources( void )
 				nTotalSize += p->nDownloadSize;
 			}
 			break;
+		case t_world:
+			ASSERT( 0 );
+			break;
 		}
 	}
 
 	return nTotalSize;
 }
 
-void CL_StartResourceDownloading( const char *pszMessage, qboolean bCustom )
+static void CL_StartResourceDownloading( const char *pszMessage, qboolean bCustom )
 {
 	resourceinfo_t	ri;
 
@@ -608,6 +604,8 @@ void CL_StartResourceDownloading( const char *pszMessage, qboolean bCustom )
 	}
 	else
 	{
+		HTTP_ResetProcessState();
+
 		cls.state = ca_validate;
 		cls.dl.custom = false;
 	}
@@ -653,7 +651,7 @@ void CL_RemoveCustomization( int nPlayerNum, customization_t *pRemove )
 			if( pList->resource.type == t_decal )
 			{
 				if( cls.state == ca_active )
-					R_DecalRemoveAll( pList->nUserData1 );
+					ref.dllFuncs.R_DecalRemoveAll( pList->nUserData1 );
 				FS_FreeImage( pList->pInfo );
 			}
 		}
@@ -848,54 +846,90 @@ void CL_ParseFileTransferFailed( sizebuf_t *msg )
 CL_ParseServerData
 ==================
 */
-void CL_ParseServerData( sizebuf_t *msg )
+void CL_ParseServerData( sizebuf_t *msg, qboolean legacy )
 {
 	char	gamefolder[MAX_QPATH];
+	string	mapfile;
 	qboolean	background;
 	int	i;
+	uint32_t	mapCRC;
+
+	HPAK_CheckSize( CUSTOM_RES_PATH );
+
+	Con_Reportf( "%s packet received.\n", legacy ? "Legacy serverdata" : "Serverdata" );
 
-	Con_Reportf( "Serverdata packet received.\n" );
 	cls.timestart = Sys_DoubleTime();
-
 	cls.demowaiting = false;	// server is changed
 
 	// wipe the client_t struct
 	if( !cls.changelevel && !cls.changedemo )
 		CL_ClearState ();
+
+	// Re-init hud video, especially if we changed game directories
+	clgame.dllFuncs.pfnVidInit();
+
 	cls.state = ca_connected;
 
 	// parse protocol version number
 	i = MSG_ReadLong( msg );
 
+	if( legacy )
+	{
+		if( i != PROTOCOL_LEGACY_VERSION )
+			Host_Error( "Server use invalid protocol (%i should be %i)\n", i, PROTOCOL_LEGACY_VERSION );
+	}
+	else
+	{
 		if( i != PROTOCOL_VERSION )
 			Host_Error( "Server use invalid protocol (%i should be %i)\n", i, PROTOCOL_VERSION );
+	}
 
 	cl.servercount = MSG_ReadLong( msg );
 	cl.checksum = MSG_ReadLong( msg );
 	cl.playernum = MSG_ReadByte( msg );
 	cl.maxclients = MSG_ReadByte( msg );
 	clgame.maxEntities = MSG_ReadWord( msg );
-	clgame.maxEntities = bound( 600, clgame.maxEntities, MAX_EDICTS );
+	if( legacy )
+	{
+		clgame.maxEntities = bound( MIN_LEGACY_EDICTS, clgame.maxEntities, MAX_LEGACY_EDICTS );
+		clgame.maxModels = 512; // ???
+	}
+	else
+	{
+		clgame.maxEntities = bound( MIN_EDICTS, clgame.maxEntities, MAX_EDICTS );
 		clgame.maxModels = MSG_ReadWord( msg );
-	Q_strncpy( clgame.mapname, MSG_ReadString( msg ), MAX_STRING );
+	}
-	Q_strncpy( clgame.maptitle, MSG_ReadString( msg ), MAX_STRING );
+	Q_strncpy( clgame.mapname, MSG_ReadString( msg ), sizeof( clgame.mapname ));
+	Q_strncpy( clgame.maptitle, MSG_ReadString( msg ), sizeof( clgame.maptitle ));
 	background = MSG_ReadOneBit( msg );
-	Q_strncpy( gamefolder, MSG_ReadString( msg ), MAX_QPATH );
+	Q_strncpy( gamefolder, MSG_ReadString( msg ), sizeof( gamefolder ));
 	host.features = (uint)MSG_ReadLong( msg );
 
+	if( !legacy )
+	{
 		// receive the player hulls
 		for( i = 0; i < MAX_MAP_HULLS * 3; i++ )
 		{
 			host.player_mins[i/3][i%3] = MSG_ReadChar( msg );
 			host.player_maxs[i/3][i%3] = MSG_ReadChar( msg );
 		}
+	}
+
+	Q_snprintf( mapfile, sizeof( mapfile ), "maps/%s.bsp", clgame.mapname );
+	if( CRC32_MapFile( &mapCRC, mapfile, cl.maxclients > 1 ))
+	{
+		// validate map checksum
+		if( mapCRC != cl.checksum )
+		{
+			Con_Printf( S_ERROR "Your map [%s] differs from the server's.\n", clgame.mapname );
+			CL_Disconnect_f(); // for local game, call EndGame
+			Host_AbortCurrentFrame(); // to avoid svc_bad
+		}
+	}
 
 	if( clgame.maxModels > MAX_MODELS )
 		Con_Printf( S_WARN "server model limit is above client model limit %i > %i\n", clgame.maxModels, MAX_MODELS );
 
-	// Re-init hud video, especially if we changed game directories
-	clgame.dllFuncs.pfnVidInit();
-
 	if( Con_FixedFont( ))
 	{
 		// seperate the printfs so the server message can have a color
@@ -912,18 +946,14 @@ void CL_ParseServerData( sizebuf_t *msg )
 		// loading user settings
 		CSCR_LoadDefaultCVars( "user.scr" );
 
-		if( r_decals->value > mp_decals.value )
+		if( r_decals.value > mp_decals.value )
-			Cvar_SetValue( "r_decals", mp_decals.value );
+			Cvar_DirectSet( &r_decals, mp_decals.string );
 	}
-	else Cvar_Reset( "r_decals" );
+	else Cvar_DirectSet( &r_decals, NULL );
 
 	// set the background state
 	if( cls.demoplayback && ( cls.demonum != -1 ))
-	{
-		// re-init mouse
-		host.mouse_visible = false;
 		cl.background = true;
-	}
 	else cl.background = background;
 
 	if( cl.background )	// tell the game parts about background state
@@ -951,17 +981,17 @@ void CL_ParseServerData( sizebuf_t *msg )
 	Q_strncpy( gameui.globals->maptitle, clgame.maptitle, sizeof( gameui.globals->maptitle ));
 
 	if( !cls.changelevel && !cls.changedemo )
-		CL_InitEdicts (); // re-arrange edicts
+		CL_InitEdicts( cl.maxclients ); // re-arrange edicts
 
 	// get splash name
 	if( cls.demoplayback && ( cls.demonum != -1 ))
-		Cvar_Set( "cl_levelshot_name", va( "levelshots/%s_%s", cls.demoname, glState.wideScreen ? "16x9" : "4x3" ));
+		Cvar_Set( "cl_levelshot_name", va( "levelshots/%s_%s", cls.demoname, refState.wideScreen ? "16x9" : "4x3" ));
-	else Cvar_Set( "cl_levelshot_name", va( "levelshots/%s_%s", clgame.mapname, glState.wideScreen ? "16x9" : "4x3" ));
+	else Cvar_Set( "cl_levelshot_name", va( "levelshots/%s_%s", clgame.mapname, refState.wideScreen ? "16x9" : "4x3" ));
 	Cvar_SetValue( "scr_loading", 0.0f ); // reset progress bar
 
-	if(( cl_allow_levelshots->value && !cls.changelevel ) || cl.background )
+	if(( cl_allow_levelshots.value && !cls.changelevel ) || cl.background )
 	{
-		if( !FS_FileExists( va( "%s.bmp", cl_levelshot_name->string ), true )) 
+		if( !FS_FileExists( va( "%s.bmp", cl_levelshot_name.string ), true ))
 			Cvar_Set( "cl_levelshot_name", "*black" ); // render a black screen
 		cls.scrshot_request = scrshot_plaque; // request levelshot even if exist (check filetime)
 	}
@@ -970,8 +1000,11 @@ void CL_ParseServerData( sizebuf_t *msg )
 		COM_ClearCustomizationList( &cl.players[i].customdata, true );
 	CL_CreateCustomizationList();
 
+	if( !legacy )
+	{
 		// request resources from server
 		CL_ServerCommand( true, "sendres %i\n", cl.servercount );
+	}
 
 	memset( &clgame.movevars, 0, sizeof( clgame.movevars ));
 	memset( &clgame.oldmovevars, 0, sizeof( clgame.oldmovevars ));
@@ -1127,7 +1160,7 @@ void CL_ParseClientData( sizebuf_t *msg )
 		if( !MSG_ReadOneBit( msg )) break;
 
 		// read the weapon idx
-		idx = MSG_ReadUBitLong( msg, MAX_WEAPON_BITS );
+		idx = MSG_ReadUBitLong( msg, cls.legacymode ? MAX_LEGACY_WEAPON_BITS : MAX_WEAPON_BITS );
 
 		MSG_ReadWeaponData( msg, &from_wd[idx], &to_wd[idx], cl.mtime[0] );
 	}
@@ -1146,7 +1179,7 @@ void CL_ParseClientData( sizebuf_t *msg )
 CL_ParseBaseline
 ==================
 */
-void CL_ParseBaseline( sizebuf_t *msg )
+void CL_ParseBaseline( sizebuf_t *msg, qboolean legacy )
 {
 	int		i, newnum;
 	entity_state_t	nullstate;
@@ -1158,9 +1191,16 @@ void CL_ParseBaseline( sizebuf_t *msg )
 	memset( &nullstate, 0, sizeof( nullstate ));
 
 	while( 1 )
+	{
+		if( legacy )
+		{
+			newnum = MSG_ReadWord( msg );
+		}
+		else
 		{
 			newnum = MSG_ReadUBitLong( msg, MAX_ENTITY_BITS );
 			if( newnum == LAST_EDICT ) break; // end of baselines
+		}
 		player = CL_IsPlayerIndex( newnum );
 
 		if( newnum >= clgame.maxEntities )
@@ -1171,8 +1211,15 @@ void CL_ParseBaseline( sizebuf_t *msg )
 		ent->index = newnum;
 
 		MSG_ReadDeltaEntity( msg, &ent->prevstate, &ent->baseline, newnum, player, 1.0f );
+
+		if( legacy )
+		{
+			break; // only one baseline allowed in legacy protocol
+		}
 	}
 
+	if( !legacy )
+	{
 		cl.instanced_baseline_count = MSG_ReadUBitLong( msg, 6 );
 
 		for( i = 0; i < cl.instanced_baseline_count; i++ )
@@ -1181,6 +1228,7 @@ void CL_ParseBaseline( sizebuf_t *msg )
 			MSG_ReadDeltaEntity( msg, &nullstate, &cl.instanced_baseline[i], newnum, false, 1.0f );
 		}
 	}
+}
 
 /*
 ================
@@ -1209,9 +1257,7 @@ set the view angle to this absolute value
 */
 void CL_ParseSetAngle( sizebuf_t *msg )
 {
-	cl.viewangles[0] = MSG_ReadBitAngle( msg, 16 );
+	MSG_ReadVec3Angles( msg, cl.viewangles );
-	cl.viewangles[1] = MSG_ReadBitAngle( msg, 16 );
-	cl.viewangles[2] = MSG_ReadBitAngle( msg, 16 );
 }
 
 /*
@@ -1294,14 +1340,26 @@ register new user message or update existing
 void CL_RegisterUserMessage( sizebuf_t *msg )
 {
 	char	*pszName;
-	int	svc_num, size;
+	int	svc_num, size, bits;
 
 	svc_num = MSG_ReadByte( msg );
+
+	if( cls.legacymode )
+	{
+		size = MSG_ReadByte( msg );
+		bits = 8;
+	}
+	else
+	{
 		size = MSG_ReadWord( msg );
+		bits = 16;
+	}
+
 	pszName = MSG_ReadString( msg );
 
 	// important stuff
-	if( size == 0xFFFF ) size = -1;
+	if( size == ( BIT( bits ) - 1 ) )
+		size = -1;
 	svc_num = bound( 0, svc_num, 255 );
 
 	CL_LinkUserMessage( pszName, svc_num, size );
@@ -1314,7 +1372,7 @@ CL_UpdateUserinfo
 collect userinfo from all players
 ================
 */
-void CL_UpdateUserinfo( sizebuf_t *msg )
+void CL_UpdateUserinfo( sizebuf_t *msg, qboolean legacy )
 {
 	int		slot, id;
 	qboolean		active;
@@ -1325,6 +1383,7 @@ void CL_UpdateUserinfo( sizebuf_t *msg )
 	if( slot >= MAX_CLIENTS )
 		Host_Error( "CL_ParseServerMessage: svc_updateuserinfo >= MAX_CLIENTS\n" );
 
+	if( !legacy )
 		id = MSG_ReadLong( msg );	// unique user ID
 	player = &cl.players[slot];
 	active = MSG_ReadOneBit( msg ) ? true : false;
@@ -1337,11 +1396,17 @@ void CL_UpdateUserinfo( sizebuf_t *msg )
 		player->topcolor = Q_atoi( Info_ValueForKey( player->userinfo, "topcolor" ));
 		player->bottomcolor = Q_atoi( Info_ValueForKey( player->userinfo, "bottomcolor" ));
 		player->spectator = Q_atoi( Info_ValueForKey( player->userinfo, "*hltv" ));
+		if( !legacy )
 			MSG_ReadBytes( msg, player->hashedcdkey, sizeof( player->hashedcdkey ));
 
 		if( slot == cl.playernum ) memcpy( &gameui.playerinfo, player, sizeof( player_info_t ));
 	}
-	else memset( player, 0, sizeof( *player ));
+	else
+	{
+		COM_ClearCustomizationList( &player->customdata, true );
+
+		memset( player, 0, sizeof( *player ));
+	}
 }
 
 /*
@@ -1369,6 +1434,36 @@ void CL_ParseResource( sizebuf_t *msg )
 	if( MSG_ReadOneBit( msg ))
 		MSG_ReadBytes( msg, pResource->rguc_reserved, sizeof( pResource->rguc_reserved ));
 
+	if( pResource->type == t_sound && pResource->nIndex > MAX_SOUNDS )
+	{
+		Mem_Free( pResource );
+		Host_Error( "bad sound index\n" );
+	}
+
+	if( pResource->type == t_model && pResource->nIndex > MAX_MODELS )
+	{
+		Mem_Free( pResource );
+		Host_Error( "bad model index\n" );
+	}
+
+	if( pResource->type == t_eventscript && pResource->nIndex > MAX_EVENTS )
+	{
+		Mem_Free( pResource );
+		Host_Error( "bad event index\n" );
+	}
+
+	if( pResource->type == t_generic && pResource->nIndex > MAX_CUSTOM )
+	{
+		Mem_Free( pResource );
+		Host_Error( "bad file index\n" );
+	}
+
+	if( pResource->type == t_decal && pResource->nIndex > MAX_DECALS )
+	{
+		Mem_Free( pResource );
+		Host_Error( "bad decal index\n" );
+	}
+
 	CL_AddToResourceList( pResource, &cl.resourcesneeded );
 }
 
@@ -1424,7 +1519,7 @@ void CL_SendConsistencyInfo( sizebuf_t *msg )
 		MSG_WriteUBitLong( msg, pc->orig_index, MAX_MODEL_BITS );
 
 		if( pc->issound )
-			Q_snprintf( filename, sizeof( filename ), "%s%s", DEFAULT_SOUNDPATH, pc->filename );
+			Q_snprintf( filename, sizeof( filename ), DEFAULT_SOUNDPATH "%s", pc->filename );
 		else Q_strncpy( filename, pc->filename, sizeof( filename ));
 
 		if( Q_strstr( filename, "models/" ))
@@ -1439,7 +1534,8 @@ void CL_SendConsistencyInfo( sizebuf_t *msg )
 		{
 		case force_exactfile:
 			MD5_HashFile( md5, filename, NULL );
-			pc->value = *(int *)md5;
+			memcpy( &pc->value, md5, sizeof( pc->value ));
+			LittleLongSW( pc->value );
 
 			if( user_changed_diskfile )
 				MSG_WriteUBitLong( msg, 0, 32 );
@@ -1463,6 +1559,42 @@ void CL_SendConsistencyInfo( sizebuf_t *msg )
 	MSG_WriteOneBit( msg, 0 );
 }
 
+/*
+==================
+CL_StartDark
+==================
+*/
+static void CL_StartDark( void )
+{
+	if( v_dark.value )
+	{
+		screenfade_t		*sf = &clgame.fade;
+		float			fadetime = 5.0f;
+		client_textmessage_t	*title;
+
+		title = CL_TextMessageGet( "GAMETITLE" );
+		if( Host_IsQuakeCompatible( ))
+			fadetime = 1.0f;
+
+		if( title )
+		{
+			// get settings from titles.txt
+			sf->fadeEnd = title->holdtime + title->fadeout;
+			sf->fadeReset = title->fadeout;
+		}
+		else sf->fadeEnd = sf->fadeReset = fadetime;
+
+		sf->fadeFlags = FFADE_IN;
+		sf->fader = sf->fadeg = sf->fadeb = 0;
+		sf->fadealpha = 255;
+		sf->fadeSpeed = (float)sf->fadealpha / sf->fadeReset;
+		sf->fadeReset += cl.time;
+		sf->fadeEnd += sf->fadeReset;
+
+		Cvar_DirectSet( &v_dark, "0" );
+	}
+}
+
 /*
 ==================
 CL_RegisterResources
@@ -1475,7 +1607,7 @@ void CL_RegisterResources( sizebuf_t *msg )
 	model_t	*mod;
 	int	i;
 
-	if( cls.dl.custom || cls.signon == SIGNONS && cls.state == ca_active )
+	if( cls.dl.custom || ( cls.signon == SIGNONS && cls.state == ca_active ) )
 	{
 		cls.dl.custom = false;
 		return;
@@ -1506,19 +1638,22 @@ void CL_RegisterResources( sizebuf_t *msg )
 
 			CL_ClearWorld ();
 
+			// update the ref state.
+			R_UpdateRefState ();
+
 			// tell rendering system we have a new set of models.
-			R_NewMap ();
+			ref.dllFuncs.R_NewMap ();
+
+			// check if this map must start from dark screen
+			CL_StartDark ();
 
 			CL_SetupOverviewParams();
 
-			if( clgame.drawFuncs.R_NewMap != NULL )
-				clgame.drawFuncs.R_NewMap();
-
 			// release unused SpriteTextures
 			for( i = 1, mod = clgame.sprites; i < MAX_CLIENT_SPRITES; i++, mod++ )
 			{
 				if( mod->needload == NL_UNREFERENCED && COM_CheckString( mod->name ))
-					Mod_UnloadSpriteModel( mod );
+					Mod_FreeModel( mod );
 			}
 
 			Mod_FreeUnused ();
@@ -1529,7 +1664,7 @@ void CL_RegisterResources( sizebuf_t *msg )
 			// done with all resources, issue prespawn command.
 			// Include server count in case server disconnects and changes level during d/l
 			MSG_BeginClientCmd( msg, clc_stringcmd );
-			MSG_WriteString( msg, va( "spawn %i", cl.servercount ));
+			MSG_WriteStringf( msg, "spawn %i", cl.servercount );
 		}
 	}
 	else
@@ -1643,7 +1778,10 @@ CL_ParseVoiceInit
 */
 void CL_ParseVoiceInit( sizebuf_t *msg )
 {
-	// TODO: ???
+	char *pszCodec = MSG_ReadString( msg );
+	int quality = MSG_ReadByte( msg );
+
+	Voice_Init( pszCodec, quality );
 }
 
 /*
@@ -1654,7 +1792,31 @@ CL_ParseVoiceData
 */
 void CL_ParseVoiceData( sizebuf_t *msg )
 {
-	// TODO: ???
+	int size, idx, frames;
+	byte received[8192];
+
+	idx = MSG_ReadByte( msg ) + 1;
+
+	frames = MSG_ReadByte( msg );
+
+	size = MSG_ReadShort( msg );
+	size = Q_min( size, sizeof( received ));
+
+	MSG_ReadBytes( msg, received, size );
+
+	if ( idx <= 0 || idx > cl.maxclients )
+		return;
+
+	// must notify through as both local player and normal client
+	if( idx == cl.playernum + 1 )
+		Voice_StatusAck( &voice.local, VOICE_LOOPBACK_INDEX );
+
+	Voice_StatusAck( &voice.players_status[idx], idx );
+
+	if ( !size )
+		return;
+
+	Voice_AddIncomingData( idx, received, size, frames );
 }
 
 /*
@@ -1665,16 +1827,23 @@ CL_ParseResLocation
 */
 void CL_ParseResLocation( sizebuf_t *msg )
 {
-	const char	*url = MSG_ReadString( msg );
+	char *data = MSG_ReadString( msg );
+	char token[256];
 
-	if( url && ( !Q_strnicmp( "http://", url, 7 ) || !Q_strnicmp( "https://", url, 8 )))
+	if( Q_strlen( data ) > 256 )
 	{
-		const char	*lastSlash = Q_strrchr( url, '/' );
+		Con_Printf( S_ERROR "Resource location too long!\n" );
+		return;
+	}
 
-		if( lastSlash && lastSlash[1] == '\0' )
+	while( ( data = COM_ParseFile( data, token, sizeof( token ) ) ) )
-			Q_strncpy( cl.downloadUrl, url, sizeof( cl.downloadUrl ));
+	{
-		else Q_snprintf( cl.downloadUrl, sizeof( cl.downloadUrl ), "%s/", url );
+		Con_Reportf( "Adding %s as download location\n", token );
-		Con_Reportf( "Using %s as primary download location\n", cl.downloadUrl );
+
+		if( !cl.downloadUrl[0] )
+			Q_strncpy( cl.downloadUrl, token, sizeof( token ) );
+
+		HTTP_AddCustomServer( token );
 	}
 }
 
@@ -1740,10 +1909,17 @@ Set screen shake
 */
 void CL_ParseScreenShake( sizebuf_t *msg )
 {
-	clgame.shake.amplitude = (float)(word)MSG_ReadShort( msg ) * (1.0f / (float)(1<<12));
+	float amplitude = (float)(word)MSG_ReadShort( msg ) * ( 1.0f / (float)( 1 << 12 ));
-	clgame.shake.duration = (float)(word)MSG_ReadShort( msg ) * (1.0f / (float)(1<<12));
+	float duration  = (float)(word)MSG_ReadShort( msg ) * ( 1.0f / (float)( 1 << 12 ));
-	clgame.shake.frequency = (float)(word)MSG_ReadShort( msg ) * (1.0f / (float)(1<<8));
+	float frequency = (float)(word)MSG_ReadShort( msg ) * ( 1.0f / (float)( 1 << 8 ));
-	clgame.shake.time = cl.time + max( clgame.shake.duration, 0.01f );
+
+	// don't overwrite larger existing shake
+	if( amplitude > clgame.shake.amplitude )
+		clgame.shake.amplitude = amplitude;
+
+	clgame.shake.duration = duration;
+	clgame.shake.time = cl.time + clgame.shake.duration;
+	clgame.shake.frequency = frequency;
 	clgame.shake.next_shake = 0.0f; // apply immediately
 }
 
@@ -1763,7 +1939,7 @@ void CL_ParseScreenFade( sizebuf_t *msg )
 	duration = (float)MSG_ReadWord( msg );
 	holdTime = (float)MSG_ReadWord( msg );
 	sf->fadeFlags = MSG_ReadShort( msg );
-	flScale = ( sf->fadeFlags & FFADE_LONGFADE ) ? (1.0f / 256.0f) : (1.0f / 4096.0f);
+	flScale = FBitSet( sf->fadeFlags, FFADE_LONGFADE ) ? (1.0f / 256.0f) : (1.0f / 4096.0f);
 
 	sf->fader = MSG_ReadByte( msg );
 	sf->fadeg = MSG_ReadByte( msg );
@@ -1776,7 +1952,7 @@ void CL_ParseScreenFade( sizebuf_t *msg )
 	// calc fade speed
 	if( duration > 0 )
 	{
-		if( sf->fadeFlags & FFADE_OUT )
+		if( FBitSet( sf->fadeFlags, FFADE_OUT ))
 		{
 			if( sf->fadeEnd )
 			{
@@ -1784,6 +1960,7 @@ void CL_ParseScreenFade( sizebuf_t *msg )
 			}
 
 			sf->fadeEnd += cl.time;
+			sf->fadeTotalEnd = sf->fadeEnd;
 			sf->fadeReset += sf->fadeEnd;
 		}
 		else
@@ -1807,45 +1984,88 @@ Find the client cvar value
 and sent it back to the server
 ==============
 */
-void CL_ParseCvarValue( sizebuf_t *msg )
+void CL_ParseCvarValue( sizebuf_t *msg, const qboolean ext )
 {
-	const char *cvarName = MSG_ReadString( msg );
+	const char *cvarName, *response;
-	convar_t *cvar = Cvar_FindVar( cvarName );
+	convar_t *cvar;
+	int requestID;
 
-	// build the answer
+	if( ext )
+		requestID = MSG_ReadLong( msg );
+
+	cvarName = MSG_ReadString( msg );
+	cvar = Cvar_FindVar( cvarName );
+
+	if( cvar )
+	{
+		if( cvar->flags & FCVAR_PRIVILEGED )
+			response = "CVAR is privileged";
+		else if( cvar->flags & FCVAR_SERVER )
+			response = "CVAR is server-only";
+		else if( cvar->flags & FCVAR_PROTECTED )
+			response = "CVAR is protected";
+		else
+			response = cvar->string;
+	}
+	else response = "Bad CVAR request";
+
+	if( ext )
+	{
+		MSG_BeginClientCmd( &cls.netchan.message, clc_requestcvarvalue2 );
+		MSG_WriteLong( &cls.netchan.message, requestID );
+		MSG_WriteString( &cls.netchan.message, cvarName );
+	}
+	else
+	{
 		MSG_BeginClientCmd( &cls.netchan.message, clc_requestcvarvalue );
-	MSG_WriteString( &cls.netchan.message, cvar ? cvar->string : "Not Found" );
+	}
+	MSG_WriteString( &cls.netchan.message, response );
 }
 
 /*
 ==============
-CL_ParseCvarValue2
+CL_ParseExec
 
-Find the client cvar value
+Exec map/class specific configs
-and sent it back to the server
 ==============
 */
-void CL_ParseCvarValue2( sizebuf_t *msg )
+void CL_ParseExec( sizebuf_t *msg )
 {
-	int requestID = MSG_ReadLong( msg );
+	qboolean is_class;
-	const char *cvarName = MSG_ReadString( msg );
+	int class_idx;
-	convar_t *cvar = Cvar_FindVar( cvarName );
+	string mapname;
+	const char *class_cfgs[] = {
+		"",
+		"exec scout.cfg\n",
+		"exec sniper.cfg\n",
+		"exec soldier.cfg\n",
+		"exec demoman.cfg\n",
+		"exec medic.cfg\n",
+		"exec hwguy.cfg\n",
+		"exec pyro.cfg\n",
+		"exec spy.cfg\n",
+		"exec engineer.cfg\n",
+		"",
+		"exec civilian.cfg\n"
+	};
 
-	// build the answer
+	is_class = MSG_ReadByte( msg );
-	MSG_BeginClientCmd( &cls.netchan.message, clc_requestcvarvalue2 );
-	MSG_WriteLong( &cls.netchan.message, requestID );
-	MSG_WriteString( &cls.netchan.message, cvarName );
 
-	if( cvar )
+	if ( is_class )
 	{
-		// cheater can change value ignoring Cvar_Set so we responce incorrect value
+		class_idx = MSG_ReadByte( msg );
-		if( cvar->value != Q_atof( cvar->string ))
+
-			MSG_WriteString( &cls.netchan.message, va( "%s (%g)", cvar->string, cvar->value ));
+		if ( class_idx >= 0 && class_idx <= 11 && !Q_stricmp( GI->gamefolder, "tfc" ) )
-		else MSG_WriteString( &cls.netchan.message, cvar->string );
+			Cbuf_AddText( class_cfgs[class_idx] );
 	}
-	else
+	else if ( !Q_stricmp( GI->gamefolder, "tfc" ) )
 	{
-		MSG_WriteString( &cls.netchan.message, "Not Found" );
+		Cbuf_AddText( "exec mapdefault.cfg\n" );
+
+		COM_FileBase( clgame.mapname, mapname, sizeof( mapname ));
+
+		if ( COM_CheckString( mapname ) )
+			Cbuf_AddTextf( "exec %s.cfg\n", mapname );
 	}
 }
 
@@ -1933,11 +2153,28 @@ void CL_ParseUserMessage( sizebuf_t *msg, int svc_num )
 	iSize = clgame.msg[i].size;
 
 	// message with variable sizes receive an actual size as first byte
-	if( iSize == -1 ) iSize = MSG_ReadWord( msg );
+	if( iSize == -1 )
+	{
+		if( cls.legacymode )
+			iSize = MSG_ReadByte( msg );
+		else iSize = MSG_ReadWord( msg );
+	}
+
+	if( iSize >= MAX_USERMSG_LENGTH )
+	{
+		Msg("WTF??? %d %d\n", i, svc_num );
+		return;
+	}
 
 	// parse user message into buffer
 	MSG_ReadBytes( msg, pbuf, iSize );
 
+	if( cl_trace_messages.value )
+	{
+		Con_Reportf( "^3USERMSG %s SIZE %i SVC_NUM %i\n",
+			clgame.msg[i].name, iSize, clgame.msg[i].number );
+	}
+
 	if( clgame.msg[i].func )
 	{
 		clgame.msg[i].func( clgame.msg[i].name, iSize, pbuf );
@@ -2039,6 +2276,8 @@ void CL_ParseServerMessage( sizebuf_t *msg, qboolean normal_message )
 			old_background = cl.background;
 			if( MSG_ReadOneBit( msg ))
 			{
+				int maxclients = cl.maxclients;
+
 				cls.changelevel = true;
 				S_StopAllSounds( true );
 
@@ -2051,7 +2290,7 @@ void CL_ParseServerMessage( sizebuf_t *msg, qboolean normal_message )
 				}
 
 				CL_ClearState();
-				CL_InitEdicts (); // re-arrange edicts
+				CL_InitEdicts( maxclients ); // re-arrange edicts
 			}
 			else Con_Printf( "Server disconnected, reconnecting\n" );
 
@@ -2068,6 +2307,7 @@ void CL_ParseServerMessage( sizebuf_t *msg, qboolean normal_message )
 				else cls.state = ca_connecting;
 				cl.background = old_background;
 				cls.connect_time = MAX_HEARTBEAT;
+				cls.connect_retry = 0;
 			}
 			break;
 		case svc_setview:
@@ -2086,24 +2326,24 @@ void CL_ParseServerMessage( sizebuf_t *msg, qboolean normal_message )
 		case svc_stufftext:
 			s = MSG_ReadString( msg );
 #ifdef HACKS_RELATED_HLMODS
-			// dsiable Cry Of Fear antisave protection
+			// disable Cry Of Fear antisave protection
 			if( !Q_strnicmp( s, "disconnect", 10 ) && cls.signon != SIGNONS )
 				break; // too early
 #endif
-			Cbuf_AddText( s );
+			Cbuf_AddFilteredText( s );
 			break;
 		case svc_setangle:
 			CL_ParseSetAngle( msg );
 			break;
 		case svc_serverdata:
 			Cbuf_Execute(); // make sure any stuffed commands are done
-			CL_ParseServerData( msg );
+			CL_ParseServerData( msg, false );
 			break;
 		case svc_lightstyle:
 			CL_ParseLightStyle( msg );
 			break;
 		case svc_updateuserinfo:
-			CL_UpdateUserinfo( msg );
+			CL_UpdateUserinfo( msg, false );
 			break;
 		case svc_deltatable:
 			Delta_ParseTableField( msg );
@@ -2133,7 +2373,7 @@ void CL_ParseServerMessage( sizebuf_t *msg, qboolean normal_message )
 			cl.frames[cl.parsecountmod].graphdata.event += MSG_GetNumBytesRead( msg ) - bufStart;
 			break;
 		case svc_spawnbaseline:
-			CL_ParseBaseline( msg );
+			CL_ParseBaseline( msg, false );
 			break;
 		case svc_temp_entity:
 			CL_ParseTempEntity( msg );
@@ -2231,15 +2471,19 @@ void CL_ParseServerMessage( sizebuf_t *msg, qboolean normal_message )
 			break;
 		case svc_voicedata:
 			CL_ParseVoiceData( msg );
+			cl.frames[cl.parsecountmod].graphdata.voicebytes += MSG_GetNumBytesRead( msg ) - bufStart;
 			break;
 		case svc_resourcelocation:
 			CL_ParseResLocation( msg );
 			break;
 		case svc_querycvarvalue:
-			CL_ParseCvarValue( msg );
+			CL_ParseCvarValue( msg, false );
 			break;
 		case svc_querycvarvalue2:
-			CL_ParseCvarValue2( msg );
+			CL_ParseCvarValue( msg, true );
+			break;
+		case svc_exec:
+			CL_ParseExec( msg );
 			break;
 		default:
 			CL_ParseUserMessage( msg, cmd );

engine/client/cl_parse_48.c

@@ -0,0 +1,705 @@
+/*
+cl_parse.c - parse a message received from the server
+Copyright (C) 2008 Uncle Mike
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+*/
+
+#include "common.h"
+#include "client.h"
+#include "net_encode.h"
+#include "particledef.h"
+#include "cl_tent.h"
+#include "shake.h"
+#include "hltv.h"
+#include "input.h"
+
+
+/*
+==================
+CL_ParseStaticEntity
+
+static client entity
+==================
+*/
+void CL_LegacyParseStaticEntity( sizebuf_t *msg )
+{
+	int		i;
+	entity_state_t	state;
+	cl_entity_t	*ent;
+
+	memset( &state, 0, sizeof( state ));
+	state.modelindex = MSG_ReadShort( msg );
+	state.sequence = MSG_ReadByte( msg );
+	state.frame = MSG_ReadByte( msg );
+	state.colormap = MSG_ReadWord( msg );
+	state.skin = MSG_ReadByte( msg );
+
+	for( i = 0; i < 3; i++ )
+	{
+		state.origin[i] = MSG_ReadCoord( msg );
+		state.angles[i] = MSG_ReadBitAngle( msg, 16 );
+	}
+
+	state.rendermode = MSG_ReadByte( msg );
+
+	if( state.rendermode != kRenderNormal )
+	{
+		state.renderamt = MSG_ReadByte( msg );
+		state.rendercolor.r = MSG_ReadByte( msg );
+		state.rendercolor.g = MSG_ReadByte( msg );
+		state.rendercolor.b = MSG_ReadByte( msg );
+		state.renderfx = MSG_ReadByte( msg );
+	}
+
+	i = clgame.numStatics;
+	if( i >= MAX_STATIC_ENTITIES )
+	{
+		Con_Printf( S_ERROR "MAX_STATIC_ENTITIES limit exceeded!\n" );
+		return;
+	}
+
+	ent = &clgame.static_entities[i];
+	clgame.numStatics++;
+
+	// all states are same
+	ent->baseline = ent->curstate = ent->prevstate = state;
+	ent->index = 0; // static entities doesn't has the numbers
+
+	// statics may be respawned in game e.g. for demo recording
+	if( cls.state == ca_connected || cls.state == ca_validate )
+		ent->trivial_accept = INVALID_HANDLE;
+
+	// setup the new static entity
+	VectorCopy( ent->curstate.origin, ent->origin );
+	VectorCopy( ent->curstate.angles, ent->angles );
+	ent->model = CL_ModelHandle( state.modelindex );
+	ent->curstate.framerate = 1.0f;
+	CL_ResetLatchedVars( ent, true );
+
+	if( ent->curstate.rendermode == kRenderNormal && ent->model != NULL )
+	{
+		// auto 'solid' faces
+		if( FBitSet( ent->model->flags, MODEL_TRANSPARENT ) && Host_IsQuakeCompatible( ))
+		{
+			ent->curstate.rendermode = kRenderTransAlpha;
+			ent->curstate.renderamt = 255;
+		}
+	}
+
+	R_AddEfrags( ent );	// add link
+}
+
+void CL_LegacyParseSoundPacket( sizebuf_t *msg, qboolean is_ambient )
+{
+	vec3_t	pos;
+	int 	chan, sound;
+	float 	volume, attn;
+	int	flags, pitch, entnum;
+	sound_t	handle = 0;
+
+	flags = MSG_ReadWord( msg );
+	if( flags & SND_LEGACY_LARGE_INDEX )
+	{
+		sound = MSG_ReadWord( msg );
+		flags &= ~SND_LEGACY_LARGE_INDEX;
+	}
+	else
+		sound = MSG_ReadByte( msg );
+	chan = MSG_ReadByte( msg );
+
+	if( FBitSet( flags, SND_VOLUME ))
+		volume = (float)MSG_ReadByte( msg ) / 255.0f;
+	else volume = VOL_NORM;
+
+	if( FBitSet( flags, SND_ATTENUATION ))
+		attn = (float)MSG_ReadByte( msg ) / 64.0f;
+	else attn = ATTN_NONE;
+
+	if( FBitSet( flags, SND_PITCH ))
+		pitch = MSG_ReadByte( msg );
+	else pitch = PITCH_NORM;
+
+	// entity reletive
+	entnum = MSG_ReadWord( msg );
+
+	// positioned in space
+	MSG_ReadVec3Coord( msg, pos );
+
+	if( FBitSet( flags, SND_SENTENCE ))
+	{
+		char	sentenceName[32];
+
+		//if( FBitSet( flags, SND_SEQUENCE ))
+			//Q_snprintf( sentenceName, sizeof( sentenceName ), "!#%i", sound + MAX_SOUNDS );
+		//else
+		Q_snprintf( sentenceName, sizeof( sentenceName ), "!%i", sound );
+
+		handle = S_RegisterSound( sentenceName );
+	}
+	else handle = cl.sound_index[sound];	// see precached sound
+
+	if( !cl.audio_prepped )
+		return; // too early
+
+	// g-cont. sound and ambient sound have only difference with channel
+	if( is_ambient )
+	{
+		S_AmbientSound( pos, entnum, handle, volume, attn, pitch, flags );
+	}
+	else
+	{
+		S_StartSound( pos, entnum, chan, handle, volume, attn, pitch, flags );
+	}
+}
+/*
+================
+CL_PrecacheSound
+
+prceache sound from server
+================
+*/
+void CL_LegacyPrecacheSound( sizebuf_t *msg )
+{
+	int	soundIndex;
+
+	soundIndex = MSG_ReadUBitLong( msg, MAX_SOUND_BITS );
+
+	if( soundIndex < 0 || soundIndex >= MAX_SOUNDS )
+		Host_Error( "CL_PrecacheSound: bad soundindex %i\n", soundIndex );
+
+	Q_strncpy( cl.sound_precache[soundIndex], MSG_ReadString( msg ), sizeof( cl.sound_precache[0] ));
+
+	// when we loading map all resources is precached sequentially
+	//if( !cl.audio_prepped ) return;
+
+	cl.sound_index[soundIndex] = S_RegisterSound( cl.sound_precache[soundIndex] );
+}
+
+void CL_LegacyPrecacheModel( sizebuf_t *msg )
+{
+	int	modelIndex;
+	string model;
+
+	modelIndex = MSG_ReadUBitLong( msg, MAX_LEGACY_MODEL_BITS );
+
+	if( modelIndex < 0 || modelIndex >= MAX_MODELS )
+		Host_Error( "CL_PrecacheModel: bad modelindex %i\n", modelIndex );
+
+	Q_strncpy( model, MSG_ReadString( msg ), MAX_STRING );
+	//Q_strncpy( cl.model_precache[modelIndex], BF_ReadString( msg ), sizeof( cl.model_precache[0] ));
+
+	// when we loading map all resources is precached sequentially
+	//if( !cl.video_prepped ) return;
+	if( modelIndex == 1 && !cl.worldmodel )
+	{
+		CL_ClearWorld ();
+
+		cl.models[modelIndex] = cl.worldmodel = Mod_LoadWorld( model, true );
+		return;
+
+	}
+
+	//Mod_RegisterModel( cl.model_precache[modelIndex], modelIndex );
+
+	cl.models[modelIndex] = Mod_ForName( model, false, false );
+	cl.nummodels = Q_max( cl.nummodels, modelIndex  );
+}
+
+void CL_LegacyPrecacheEvent( sizebuf_t *msg )
+{
+	int	eventIndex;
+
+	eventIndex = MSG_ReadUBitLong( msg, MAX_EVENT_BITS );
+
+	if( eventIndex < 0 || eventIndex >= MAX_EVENTS )
+		Host_Error( "CL_PrecacheEvent: bad eventindex %i\n", eventIndex );
+
+	Q_strncpy( cl.event_precache[eventIndex], MSG_ReadString( msg ), sizeof( cl.event_precache[0] ));
+
+	// can be set now
+	CL_SetEventIndex( cl.event_precache[eventIndex], eventIndex );
+}
+
+#if XASH_LOW_MEMORY == 0
+#define MAX_LEGACY_RESOURCES 2048
+#elif XASH_LOW_MEMORY == 2
+#define MAX_LEGACY_RESOURCES 1
+#elif XASH_LOW_MEMORY == 1
+#define MAX_LEGACY_RESOURCES 512
+#endif
+/*
+==============
+CL_ParseResourceList
+
+==============
+*/
+void CL_LegacyParseResourceList( sizebuf_t *msg )
+{
+	int	i = 0;
+	static struct
+	{
+		int  rescount;
+		int  restype[MAX_LEGACY_RESOURCES];
+		char resnames[MAX_LEGACY_RESOURCES][MAX_QPATH];
+	} reslist;
+
+	memset( &reslist, 0, sizeof( reslist ));
+	reslist.rescount = MSG_ReadWord( msg ) - 1;
+
+	if( reslist.rescount > MAX_LEGACY_RESOURCES )
+		Host_Error("MAX_RESOURCES reached\n");
+
+	for( i = 0; i < reslist.rescount; i++ )
+	{
+		reslist.restype[i] = MSG_ReadWord( msg );
+		Q_strncpy( reslist.resnames[i], MSG_ReadString( msg ), MAX_QPATH );
+	}
+
+	if( CL_IsPlaybackDemo() )
+		return;
+
+	if( !cl_allow_download.value )
+	{
+		Con_DPrintf( "Refusing new resource, cl_allow_download set to 0\n" );
+		reslist.rescount = 0;
+	}
+
+	if( cls.state == ca_active && !cl_download_ingame.value )
+	{
+		Con_DPrintf( "Refusing new resource, cl_download_ingame set to 0\n" );
+		reslist.rescount = 0;
+	}
+
+	HTTP_ResetProcessState();
+
+	host.downloadcount = 0;
+
+	for( i = 0; i < reslist.rescount; i++ )
+	{
+		char soundpath[MAX_VA_STRING];
+		const char *path;
+
+		if( reslist.restype[i] == t_sound )
+		{
+			Q_snprintf( soundpath, sizeof( soundpath ), DEFAULT_SOUNDPATH "%s", reslist.resnames[i] );
+
+			path = soundpath;
+		}
+		else path = reslist.resnames[i];
+
+		if( FS_FileExists( path, false ))
+			continue;	// already exists
+
+		host.downloadcount++;
+		HTTP_AddDownload( path, -1, true );
+	}
+
+	if( !host.downloadcount )
+	{
+		MSG_WriteByte( &cls.netchan.message, clc_stringcmd );
+		MSG_WriteString( &cls.netchan.message, "continueloading" );
+	}
+}
+
+/*
+=====================
+CL_ParseLegacyServerMessage
+
+dispatch messages
+=====================
+*/
+void CL_ParseLegacyServerMessage( sizebuf_t *msg, qboolean normal_message )
+{
+	size_t		bufStart, playerbytes;
+	int		cmd, param1, param2;
+	int		old_background;
+	const char	*s;
+
+	cls.starting_count = MSG_GetNumBytesRead( msg );	// updates each frame
+	CL_Parse_Debug( true );			// begin parsing
+
+	if( normal_message )
+	{
+		// assume no entity/player update this packet
+		if( cls.state == ca_active )
+		{
+			cl.frames[cls.netchan.incoming_sequence & CL_UPDATE_MASK].valid = false;
+			cl.frames[cls.netchan.incoming_sequence & CL_UPDATE_MASK].choked = false;
+		}
+		else
+		{
+			CL_ResetFrame( &cl.frames[cls.netchan.incoming_sequence & CL_UPDATE_MASK] );
+		}
+	}
+
+	// parse the message
+	while( 1 )
+	{
+		if( MSG_CheckOverflow( msg ))
+		{
+			Host_Error( "CL_ParseServerMessage: overflow!\n" );
+			return;
+		}
+
+		// mark start position
+		bufStart = MSG_GetNumBytesRead( msg );
+
+		// end of message (align bits)
+		if( MSG_GetNumBitsLeft( msg ) < 8 )
+			break;
+
+		cmd = MSG_ReadServerCmd( msg );
+
+		// record command for debugging spew on parse problem
+		CL_Parse_RecordCommand( cmd, bufStart );
+
+		// other commands
+		switch( cmd )
+		{
+		case svc_bad:
+			Host_Error( "svc_bad\n" );
+			break;
+		case svc_nop:
+			// this does nothing
+			break;
+		case svc_disconnect:
+			CL_Drop ();
+			Host_AbortCurrentFrame ();
+			break;
+		case svc_legacy_event:
+			CL_ParseEvent( msg );
+			cl.frames[cl.parsecountmod].graphdata.event += MSG_GetNumBytesRead( msg ) - bufStart;
+			break;
+		case svc_legacy_changing:
+			old_background = cl.background;
+			if( MSG_ReadOneBit( msg ))
+			{
+				int maxclients = cl.maxclients;
+
+				cls.changelevel = true;
+				S_StopAllSounds( true );
+
+				Con_Printf( "Server changing, reconnecting\n" );
+
+				if( cls.demoplayback )
+				{
+					SCR_BeginLoadingPlaque( cl.background );
+					cls.changedemo = true;
+				}
+
+				CL_ClearState( );
+
+				// a1ba: need to restore cl.maxclients because engine chooses
+				// frame backups count depending on this value
+				// In general, it's incorrect to call CL_InitEdicts right after
+				// CL_ClearState because of this bug. Some time later this logic
+				// should be re-done.
+				CL_InitEdicts( maxclients ); // re-arrange edicts
+			}
+			else Con_Printf( "Server disconnected, reconnecting\n" );
+
+			if( cls.demoplayback )
+			{
+				cl.background = (cls.demonum != -1) ? true : false;
+				cls.state = ca_connected;
+			}
+			else
+			{
+				// g-cont. local client skip the challenge
+				if( SV_Active( ))
+					cls.state = ca_disconnected;
+				else cls.state = ca_connecting;
+				cl.background = old_background;
+				cls.connect_time = MAX_HEARTBEAT;
+				cls.connect_retry = 0;
+			}
+			break;
+		case svc_setview:
+			CL_ParseViewEntity( msg );
+			break;
+		case svc_sound:
+			CL_LegacyParseSoundPacket( msg, false );
+			cl.frames[cl.parsecountmod].graphdata.sound += MSG_GetNumBytesRead( msg ) - bufStart;
+			break;
+		case svc_legacy_ambientsound:
+			CL_LegacyParseSoundPacket( msg, true );
+			cl.frames[cl.parsecountmod].graphdata.sound += MSG_GetNumBytesRead( msg ) - bufStart;
+
+			break;
+		case svc_time:
+			CL_ParseServerTime( msg );
+			break;
+		case svc_print:
+			Con_Printf( "%s", MSG_ReadString( msg ));
+			break;
+		case svc_stufftext:
+			s = MSG_ReadString( msg );
+#ifdef HACKS_RELATED_HLMODS
+			// disable Cry Of Fear antisave protection
+			if( !Q_strnicmp( s, "disconnect", 10 ) && cls.signon != SIGNONS )
+				break; // too early
+#endif
+
+			Con_Reportf( "Stufftext: %s", s );
+			Cbuf_AddFilteredText( s );
+			break;
+		case svc_setangle:
+			CL_ParseSetAngle( msg );
+			break;
+		case svc_serverdata:
+			Cbuf_Execute(); // make sure any stuffed commands are done
+			CL_ParseServerData( msg, true );
+			break;
+		case svc_lightstyle:
+			CL_ParseLightStyle( msg );
+			break;
+		case svc_updateuserinfo:
+			CL_UpdateUserinfo( msg, true );
+			break;
+		case svc_deltatable:
+			Delta_ParseTableField( msg );
+			break;
+		case svc_clientdata:
+			CL_ParseClientData( msg );
+			cl.frames[cl.parsecountmod].graphdata.client += MSG_GetNumBytesRead( msg ) - bufStart;
+			break;
+		case svc_resource:
+			CL_ParseResource( msg );
+			break;
+		case svc_pings:
+			CL_UpdateUserPings( msg );
+			break;
+		case svc_particle:
+			CL_ParseParticles( msg );
+			break;
+		case svc_restoresound:
+			CL_ParseRestoreSoundPacket( msg );
+			cl.frames[cl.parsecountmod].graphdata.sound += MSG_GetNumBytesRead( msg ) - bufStart;
+			break;
+		case svc_spawnstatic:
+			CL_LegacyParseStaticEntity( msg );
+			break;
+		case svc_event_reliable:
+			CL_ParseReliableEvent( msg );
+			cl.frames[cl.parsecountmod].graphdata.event += MSG_GetNumBytesRead( msg ) - bufStart;
+			break;
+		case svc_spawnbaseline:
+			CL_ParseBaseline( msg, true );
+			break;
+		case svc_temp_entity:
+			CL_ParseTempEntity( msg );
+			cl.frames[cl.parsecountmod].graphdata.tentities += MSG_GetNumBytesRead( msg ) - bufStart;
+			break;
+		case svc_setpause:
+			cl.paused = ( MSG_ReadOneBit( msg ) != 0 );
+			break;
+		case svc_signonnum:
+			CL_ParseSignon( msg );
+			break;
+		case svc_centerprint:
+			CL_CenterPrint( MSG_ReadString( msg ), 0.25f );
+			break;
+		case svc_intermission:
+			cl.intermission = 1;
+			break;
+		case svc_legacy_modelindex:
+			CL_LegacyPrecacheModel( msg );
+			break;
+		case svc_legacy_soundindex:
+			CL_LegacyPrecacheSound( msg );
+			break;
+		case svc_cdtrack:
+			param1 = MSG_ReadByte( msg );
+			param1 = bound( 1, param1, MAX_CDTRACKS ); // tracknum
+			param2 = MSG_ReadByte( msg );
+			param2 = bound( 1, param2, MAX_CDTRACKS ); // loopnum
+			S_StartBackgroundTrack( clgame.cdtracks[param1-1], clgame.cdtracks[param2-1], 0, false );
+			break;
+		case svc_restore:
+			CL_ParseRestore( msg );
+			break;
+		case svc_legacy_eventindex:
+			CL_LegacyPrecacheEvent(msg);
+			break;
+		case svc_weaponanim:
+			param1 = MSG_ReadByte( msg );	// iAnim
+			param2 = MSG_ReadByte( msg );	// body
+			CL_WeaponAnim( param1, param2 );
+			break;
+		case svc_bspdecal:
+			CL_ParseStaticDecal( msg );
+			break;
+		case svc_roomtype:
+			param1 = MSG_ReadShort( msg );
+			Cvar_SetValue( "room_type", param1 );
+			break;
+		case svc_addangle:
+			CL_ParseAddAngle( msg );
+			break;
+		case svc_usermessage:
+			CL_RegisterUserMessage( msg );
+			break;
+		case svc_packetentities:
+			playerbytes = CL_ParsePacketEntities( msg, false );
+			cl.frames[cl.parsecountmod].graphdata.players += playerbytes;
+			cl.frames[cl.parsecountmod].graphdata.entities += MSG_GetNumBytesRead( msg ) - bufStart - playerbytes;
+			break;
+		case svc_deltapacketentities:
+			playerbytes = CL_ParsePacketEntities( msg, true );
+			cl.frames[cl.parsecountmod].graphdata.players += playerbytes;
+			cl.frames[cl.parsecountmod].graphdata.entities += MSG_GetNumBytesRead( msg ) - bufStart - playerbytes;
+			break;
+		case svc_legacy_chokecount:
+		{
+			int i, j;
+			i = MSG_ReadByte( msg );
+			j = cls.netchan.incoming_acknowledged - 1;
+			for( ; i > 0 && j > cls.netchan.outgoing_sequence - CL_UPDATE_BACKUP; j-- )
+			{
+				if( cl.frames[j & CL_UPDATE_MASK].receivedtime != -3.0 )
+				{
+					cl.frames[j & CL_UPDATE_MASK].choked = true;
+					cl.frames[j & CL_UPDATE_MASK].receivedtime = -2.0;
+					i--;
+				}
+			}
+			break;
+		}
+			//cl.frames[cls.netchan.incoming_sequence & CL_UPDATE_MASK].choked = true;
+			//cl.frames[cls.netchan.incoming_sequence & CL_UPDATE_MASK].receivedtime = -2.0;
+			break;
+		case svc_resourcelist:
+			CL_LegacyParseResourceList( msg );
+			break;
+		case svc_deltamovevars:
+			CL_ParseMovevars( msg );
+			break;
+		case svc_resourcerequest:
+			CL_ParseResourceRequest( msg );
+			break;
+		case svc_customization:
+			CL_ParseCustomization( msg );
+			break;
+		case svc_crosshairangle:
+			CL_ParseCrosshairAngle( msg );
+			break;
+		case svc_soundfade:
+			CL_ParseSoundFade( msg );
+			break;
+		case svc_filetxferfailed:
+			CL_ParseFileTransferFailed( msg );
+			break;
+		case svc_hltv:
+			CL_ParseHLTV( msg );
+			break;
+		case svc_director:
+			CL_ParseDirector( msg );
+			break;
+		case svc_resourcelocation:
+			CL_ParseResLocation( msg );
+			break;
+		case svc_querycvarvalue:
+			CL_ParseCvarValue( msg, false );
+			break;
+		case svc_querycvarvalue2:
+			CL_ParseCvarValue( msg, true );
+			break;
+		default:
+			CL_ParseUserMessage( msg, cmd );
+			cl.frames[cl.parsecountmod].graphdata.usr += MSG_GetNumBytesRead( msg ) - bufStart;
+			break;
+		}
+	}
+
+	cl.frames[cl.parsecountmod].graphdata.msgbytes += MSG_GetNumBytesRead( msg ) - cls.starting_count;
+	CL_Parse_Debug( false ); // done
+
+	// we don't know if it is ok to save a demo message until
+	// after we have parsed the frame
+	if( !cls.demoplayback )
+	{
+		if( cls.demorecording && !cls.demowaiting )
+		{
+			CL_WriteDemoMessage( false, cls.starting_count, msg );
+		}
+		else if( cls.state != ca_active )
+		{
+			CL_WriteDemoMessage( true, cls.starting_count, msg );
+		}
+	}
+}
+
+void CL_LegacyPrecache_f( void )
+{
+	int	spawncount, i;
+	model_t *mod;
+
+	if( !cls.legacymode )
+		return;
+
+	spawncount = Q_atoi( Cmd_Argv( 1 ));
+
+	Con_Printf( "Setting up renderer...\n" );
+
+	// load tempent sprites (glowshell, muzzleflashes etc)
+	CL_LoadClientSprites ();
+
+	// invalidate all decal indexes
+	memset( cl.decal_index, 0, sizeof( cl.decal_index ));
+	cl.video_prepped = true;
+	cl.audio_prepped = true;
+	if( clgame.entities )
+		clgame.entities->model = cl.worldmodel;
+
+	// update the ref state.
+	R_UpdateRefState ();
+
+	// tell rendering system we have a new set of models.
+	ref.dllFuncs.R_NewMap ();
+
+	CL_SetupOverviewParams();
+
+	// release unused SpriteTextures
+	for( i = 1, mod = clgame.sprites; i < MAX_CLIENT_SPRITES; i++, mod++ )
+	{
+		if( mod->needload == NL_UNREFERENCED && COM_CheckString( mod->name ))
+			Mod_FreeModel( mod );
+	}
+
+//	Mod_FreeUnused ();
+
+	if( host_developer.value <= DEV_NONE )
+		Con_ClearNotify(); // clear any lines of console text
+
+	// done with all resources, issue prespawn command.
+	// Include server count in case server disconnects and changes level during d/l
+	MSG_BeginClientCmd( &cls.netchan.message, clc_stringcmd );
+	MSG_WriteStringf( &cls.netchan.message, "begin %i", spawncount );
+	cls.signon = SIGNONS;
+}
+
+void CL_LegacyUpdateInfo( void )
+{
+	if( !cls.legacymode )
+		return;
+
+	if( cls.state != ca_active )
+		return;
+
+	MSG_BeginClientCmd( &cls.netchan.message, clc_legacy_userinfo );
+	MSG_WriteString( &cls.netchan.message, cls.userinfo );
+}
+
+qboolean CL_LegacyMode( void )
+{
+	return cls.legacymode;
+}

engine/client/cl_pmove.c

@@ -26,27 +26,13 @@ GNU General Public License for more details.
 #define MIN_PREDICTION_EPSILON	0.5f	// complain if error is > this and we have cl_showerror set
 #define MAX_PREDICTION_ERROR		64.0f	// above this is assumed to be a teleport, don't smooth, etc.
 
-/*
-=============
-CL_ClearPhysEnts
-
-=============
-*/
-void CL_ClearPhysEnts( void )
-{
-	clgame.pmove->numtouch = 0;
-	clgame.pmove->numvisent = 0;
-	clgame.pmove->nummoveent = 0;
-	clgame.pmove->numphysent = 0;
-}
-
 /*
 =============
 CL_PushPMStates
 
 =============
 */
-void CL_PushPMStates( void )
+void GAME_EXPORT CL_PushPMStates( void )
 {
 	if( clgame.pushed ) return;
 	clgame.oldphyscount = clgame.pmove->numphysent;
@@ -60,7 +46,7 @@ CL_PopPMStates
 
 =============
 */
-void CL_PopPMStates( void )
+void GAME_EXPORT CL_PopPMStates( void )
 {
 	if( !clgame.pushed ) return;
 	clgame.pmove->numphysent = clgame.oldphyscount;
@@ -74,7 +60,7 @@ CL_PushTraceBounds
 
 =============
 */
-void CL_PushTraceBounds( int hullnum, const float *mins, const float *maxs )
+void GAME_EXPORT CL_PushTraceBounds( int hullnum, const float *mins, const float *maxs )
 {
 	hullnum = bound( 0, hullnum, 3 );
 	VectorCopy( mins, clgame.pmove->player_mins[hullnum] );
@@ -87,7 +73,7 @@ CL_PopTraceBounds
 
 =============
 */
-void CL_PopTraceBounds( void )
+void GAME_EXPORT CL_PopTraceBounds( void )
 {
 	memcpy( clgame.pmove->player_mins, host.player_mins, sizeof( host.player_mins ));
 	memcpy( clgame.pmove->player_maxs, host.player_maxs, sizeof( host.player_maxs ));
@@ -100,7 +86,7 @@ CL_IsPredicted
 */
 qboolean CL_IsPredicted( void )
 {
-	if( cl_nopred->value || cl.intermission )
+	if( cl_nopred.value || cl.intermission )
 		return false;
 
 	// never predict the quake demos
@@ -197,7 +183,7 @@ void CL_SetIdealPitch( void )
 	}
 
 	if( steps < 2 ) return;
-	cl.local.idealpitch = -dir * cl_idealpitchscale->value;
+	cl.local.idealpitch = -dir * cl_idealpitchscale.value;
 }
 
 /*
@@ -208,7 +194,7 @@ check for instant movement in case
 we don't want interpolate this
 ==================
 */
-qboolean CL_PlayerTeleported( local_state_t *from, local_state_t *to )
+static qboolean CL_PlayerTeleported( local_state_t *from, local_state_t *to )
 {
 	int	len, maxlen;
 	vec3_t	delta;
@@ -216,7 +202,7 @@ qboolean CL_PlayerTeleported( local_state_t *from, local_state_t *to )
 	VectorSubtract( to->playerstate.origin, from->playerstate.origin, delta );
 
 	// compute potential max movement in units per frame and compare with entity movement
-	maxlen = ( clgame.movevars.maxvelocity * ( 1.0 / GAME_FPS ));
+	maxlen = ( clgame.movevars.maxvelocity * ( 1.0f / GAME_FPS ));
 	len = VectorLength( delta );
 
 	return (len > maxlen);
@@ -248,7 +234,7 @@ void CL_CheckPredictionError( void )
 	// save the prediction error for interpolation
 	if( dist > MAX_PREDICTION_ERROR )
 	{
-		if( cl_showerror->value && host_developer.value )
+		if( cl_showerror.value && host_developer.value )
 			Con_NPrintf( 10 + ( ++pos & 3 ), "^3player teleported:^7 %.3f units\n", dist );
 
 		// a teleport or something or gamepaused
@@ -256,7 +242,7 @@ void CL_CheckPredictionError( void )
 	}
 	else
 	{
-		if( cl_showerror->value && dist > MIN_PREDICTION_EPSILON && host_developer.value )
+		if( cl_showerror.value && dist > MIN_PREDICTION_EPSILON && host_developer.value )
 			Con_NPrintf( 10 + ( ++pos & 3 ), "^1prediction error:^7 %.3f units\n", dist );
 
 		VectorCopy( cl.frames[cmd].playerstate[cl.playernum].origin, cl.local.predicted_origins[frame] );
@@ -264,8 +250,10 @@ void CL_CheckPredictionError( void )
 		// save for error interpolation
 		VectorCopy( delta, cl.local.prediction_error );
 
-		if( dist > MIN_CORRECTION_DISTANCE )
+		// GoldSrc checks for singleplayer
-			cls.correction_time = cl_smoothtime->value;
+		// we would check for local server
+		if( dist > MIN_CORRECTION_DISTANCE && !SV_Active() )
+			cls.correction_time = cl_smoothtime.value;
 	}
 }
 
@@ -280,7 +268,7 @@ then with clipping against them.
 This sets up the first phase.
 =============
 */
-void CL_SetUpPlayerPrediction( int dopred, int bIncludeLocalClient )
+void GAME_EXPORT CL_SetUpPlayerPrediction( int dopred, int bIncludeLocalClient )
 {
 	entity_state_t	*state;
 	predicted_player_t	*player;
@@ -538,14 +526,14 @@ pmove must be setup with world and solid entity hulls before calling
 (via CL_PredictMove)
 ===============
 */
-void CL_SetSolidPlayers( int playernum )
+void GAME_EXPORT CL_SetSolidPlayers( int playernum )
 {
 	entity_state_t	*state;
 	predicted_player_t	*player;
 	physent_t		*pe;
 	int		i;
 
-	if( !cl_solid_players->value )
+	if( !cl_solid_players.value )
 		return;
 
 	for( i = 0; i < MAX_CLIENTS; i++ )
@@ -594,7 +582,7 @@ CL_WaterEntity
 
 =============
 */
-int CL_WaterEntity( const float *rgflPos )
+int GAME_EXPORT CL_WaterEntity( const float *rgflPos )
 {
 	physent_t		*pe;
 	hull_t		*hull;
@@ -699,148 +687,42 @@ cl_entity_t *CL_GetWaterEntity( const float *rgflPos )
 	return CL_GetEntityByIndex( entnum );
 }
 
-int CL_TestLine( const vec3_t start, const vec3_t end, int flags )
+int GAME_EXPORT CL_TestLine( const vec3_t start, const vec3_t end, int flags )
 {
 	return PM_TestLineExt( clgame.pmove, clgame.pmove->physents, clgame.pmove->numphysent, start, end, flags );
 }
 
-static int pfnTestPlayerPosition( float *pos, pmtrace_t *ptrace )
+static int GAME_EXPORT pfnTestPlayerPosition( float *pos, pmtrace_t *ptrace )
 {
 	return PM_TestPlayerPosition( clgame.pmove, pos, ptrace, NULL );
 }
 
-static void pfnStuckTouch( int hitent, pmtrace_t *tr )
+static void GAME_EXPORT pfnStuckTouch( int hitent, pmtrace_t *tr )
 {
-	int	i;
+	PM_StuckTouch( clgame.pmove, hitent, tr );
-
-	for( i = 0; i < clgame.pmove->numtouch; i++ )
-	{
-		if( clgame.pmove->touchindex[i].ent == hitent )
-			return;
 }
 
-	if( clgame.pmove->numtouch >= MAX_PHYSENTS )
+static int GAME_EXPORT pfnTruePointContents( float *p )
-		return;
-
-	VectorCopy( clgame.pmove->velocity, tr->deltavelocity );
-	tr->ent = hitent;
-
-	clgame.pmove->touchindex[clgame.pmove->numtouch++] = *tr;
-}
-
-static int pfnPointContents( float *p, int *truecontents )
-{
-	int	cont, truecont;
-
-	truecont = cont = PM_PointContents( clgame.pmove, p );
-	if( truecontents ) *truecontents = truecont;
-
-	if( cont <= CONTENTS_CURRENT_0 && cont >= CONTENTS_CURRENT_DOWN )
-		cont = CONTENTS_WATER;
-	return cont;
-}
-
-static int pfnTruePointContents( float *p )
 {
 	return PM_TruePointContents( clgame.pmove, p );
 }
 
-static int pfnHullPointContents( struct hull_s *hull, int num, float *p )
+static pmtrace_t GAME_EXPORT pfnPlayerTrace( float *start, float *end, int traceFlags, int ignore_pe )
-{
-	return PM_HullPointContents( hull, num, p );
-}
-
-static pmtrace_t pfnPlayerTrace( float *start, float *end, int traceFlags, int ignore_pe )
 {
 	return PM_PlayerTraceExt( clgame.pmove, start, end, traceFlags, clgame.pmove->numphysent, clgame.pmove->physents, ignore_pe, NULL );
 }
 
-static pmtrace_t *pfnTraceLine( float *start, float *end, int flags, int usehull, int ignore_pe )
+static void *pfnHullForBsp( physent_t *pe, float *offset )
-{
-	static pmtrace_t	tr;
-	int		old_usehull;
-
-	old_usehull = clgame.pmove->usehull;
-	clgame.pmove->usehull = usehull;	
-
-	switch( flags )
-	{
-	case PM_TRACELINE_PHYSENTSONLY:
-		tr = PM_PlayerTraceExt( clgame.pmove, start, end, 0, clgame.pmove->numphysent, clgame.pmove->physents, ignore_pe, NULL );
-		break;
-	case PM_TRACELINE_ANYVISIBLE:
-		tr = PM_PlayerTraceExt( clgame.pmove, start, end, 0, clgame.pmove->numvisent, clgame.pmove->visents, ignore_pe, NULL );
-		break;
-	}
-
-	clgame.pmove->usehull = old_usehull;
-
-	return &tr;
-}
-
-static hull_t *pfnHullForBsp( physent_t *pe, float *offset )
 {
 	return PM_HullForBsp( pe, clgame.pmove, offset );
 }
 
-static float pfnTraceModel( physent_t *pe, float *start, float *end, trace_t *trace )
+static float GAME_EXPORT pfnTraceModel( physent_t *pe, float *start, float *end, trace_t *trace )
 {
-	int	old_usehull;
+	return PM_TraceModel( clgame.pmove, pe, start, end, trace );
-	vec3_t	start_l, end_l;
-	vec3_t	offset, temp;
-	qboolean	rotated;
-	matrix4x4	matrix;
-	hull_t	*hull;
-
-	old_usehull = clgame.pmove->usehull;
-	clgame.pmove->usehull = 2;
-
-	hull = PM_HullForBsp( pe, clgame.pmove, offset );
-
-	clgame.pmove->usehull = old_usehull;
-
-	if( pe->solid == SOLID_BSP && !VectorIsNull( pe->angles ))
-		rotated = true;
-	else rotated = false;
-
- 	if( rotated )
- 	{
- 		Matrix4x4_CreateFromEntity( matrix, pe->angles, offset, 1.0f );
- 		Matrix4x4_VectorITransform( matrix, start, start_l );
- 		Matrix4x4_VectorITransform( matrix, end, end_l );
- 	}
- 	else
- 	{
- 		VectorSubtract( start, offset, start_l );
- 		VectorSubtract( end, offset, end_l );
 }
 
-	PM_RecursiveHullCheck( hull, hull->firstclipnode, 0, 1, start_l, end_l, (pmtrace_t *)trace );
+static void GAME_EXPORT pfnPlaySound( int channel, const char *sample, float volume, float attenuation, int fFlags, int pitch )
-	trace->ent = NULL;
-
-	if( rotated )
-	{
-		VectorCopy( trace->plane.normal, temp );
-		Matrix4x4_TransformPositivePlane( matrix, temp, trace->plane.dist, trace->plane.normal, &trace->plane.dist );
-	}
-
-	VectorLerp( start, trace->fraction, end, trace->endpos );
-
-	return trace->fraction;
-}
-
-static const char *pfnTraceTexture( int ground, float *vstart, float *vend )
-{
-	physent_t *pe;
-
-	if( ground < 0 || ground >= clgame.pmove->numphysent )
-		return NULL; // bad ground
-
-	pe = &clgame.pmove->physents[ground];
-	return PM_TraceTexture( pe, vstart, vend );
-}			
-
-static void pfnPlaySound( int channel, const char *sample, float volume, float attenuation, int fFlags, int pitch )
 {
 	if( !clgame.pmove->runfuncs )
 		return;
@@ -848,54 +730,25 @@ static void pfnPlaySound( int channel, const char *sample, float volume, float a
 	S_StartSound( NULL, clgame.pmove->player_index + 1, channel, S_RegisterSound( sample ), volume, attenuation, pitch, fFlags );
 }
 
-static void pfnPlaybackEventFull( int flags, int clientindex, word eventindex, float delay, float *origin,
+static void GAME_EXPORT pfnPlaybackEventFull( int flags, int clientindex, word eventindex, float delay, float *origin,
 	float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 )
 {
 	CL_PlaybackEvent( flags, NULL, eventindex, delay, origin, angles, fparam1, fparam2, iparam1, iparam2, bparam1, bparam2 );
 }
 
-static pmtrace_t pfnPlayerTraceEx( float *start, float *end, int traceFlags, pfnIgnore pmFilter )
+static pmtrace_t GAME_EXPORT pfnPlayerTraceEx( float *start, float *end, int traceFlags, pfnIgnore pmFilter )
 {
 	return PM_PlayerTraceExt( clgame.pmove, start, end, traceFlags, clgame.pmove->numphysent, clgame.pmove->physents, -1, pmFilter );
 }
 
-static int pfnTestPlayerPositionEx( float *pos, pmtrace_t *ptrace, pfnIgnore pmFilter )
+static int GAME_EXPORT pfnTestPlayerPositionEx( float *pos, pmtrace_t *ptrace, pfnIgnore pmFilter )
 {
 	return PM_TestPlayerPosition( clgame.pmove, pos, ptrace, pmFilter );
 }
 
 static pmtrace_t *pfnTraceLineEx( float *start, float *end, int flags, int usehull, pfnIgnore pmFilter )
 {
-	static pmtrace_t	tr;
+	return PM_TraceLineEx( clgame.pmove, start, end, flags, usehull, pmFilter );
-	int		old_usehull;
-
-	old_usehull = clgame.pmove->usehull;
-	clgame.pmove->usehull = usehull;	
-
-	switch( flags )
-	{
-	case PM_TRACELINE_PHYSENTSONLY:
-		tr = PM_PlayerTraceExt( clgame.pmove, start, end, 0, clgame.pmove->numphysent, clgame.pmove->physents, -1, pmFilter );
-		break;
-	case PM_TRACELINE_ANYVISIBLE:
-		tr = PM_PlayerTraceExt( clgame.pmove, start, end, 0, clgame.pmove->numvisent, clgame.pmove->visents, -1, pmFilter );
-		break;
-	}
-
-	clgame.pmove->usehull = old_usehull;
-
-	return &tr;
-}
-
-static struct msurface_s *pfnTraceSurface( int ground, float *vstart, float *vend )
-{
-	physent_t *pe;
-
-	if( ground < 0 || ground >= clgame.pmove->numphysent )
-		return NULL; // bad ground
-
-	pe = &clgame.pmove->physents[ground];
-	return PM_TraceSurface( pe, vstart, vend );
 }
 
 /*
@@ -928,18 +781,18 @@ void CL_InitClientMove( void )
 
 	// common utilities
 	clgame.pmove->PM_Info_ValueForKey = Info_ValueForKey;
-	clgame.pmove->PM_Particle = CL_Particle;
+	clgame.pmove->PM_Particle = CL_Particle; // ref should be initialized here already
 	clgame.pmove->PM_TestPlayerPosition = pfnTestPlayerPosition;
 	clgame.pmove->Con_NPrintf = Con_NPrintf;
 	clgame.pmove->Con_DPrintf = Con_DPrintf;
 	clgame.pmove->Con_Printf = Con_Printf;
 	clgame.pmove->Sys_FloatTime = Sys_DoubleTime;
 	clgame.pmove->PM_StuckTouch = pfnStuckTouch;
-	clgame.pmove->PM_PointContents = pfnPointContents;
+	clgame.pmove->PM_PointContents = (void*)PM_CL_PointContents;
 	clgame.pmove->PM_TruePointContents = pfnTruePointContents;
-	clgame.pmove->PM_HullPointContents = pfnHullPointContents; 
+	clgame.pmove->PM_HullPointContents = (void*)PM_HullPointContents;
 	clgame.pmove->PM_PlayerTrace = pfnPlayerTrace;
-	clgame.pmove->PM_TraceLine = pfnTraceLine;
+	clgame.pmove->PM_TraceLine = PM_CL_TraceLine;
 	clgame.pmove->RandomLong = COM_RandomLong;
 	clgame.pmove->RandomFloat = COM_RandomFloat;
 	clgame.pmove->PM_GetModelType = pfnGetModelType;
@@ -951,7 +804,7 @@ void CL_InitClientMove( void )
 	clgame.pmove->COM_FreeFile = COM_FreeFile;
 	clgame.pmove->memfgets = COM_MemFgets;
 	clgame.pmove->PM_PlaySound = pfnPlaySound;
-	clgame.pmove->PM_TraceTexture = pfnTraceTexture;
+	clgame.pmove->PM_TraceTexture = PM_CL_TraceTexture;
 	clgame.pmove->PM_PlaybackEventFull = pfnPlaybackEventFull;
 	clgame.pmove->PM_PlayerTraceEx = pfnPlayerTraceEx;
 	clgame.pmove->PM_TestPlayerPositionEx = pfnTestPlayerPositionEx;
@@ -962,21 +815,10 @@ void CL_InitClientMove( void )
 	clgame.dllFuncs.pfnPlayerMoveInit( clgame.pmove );
 }
 
-static void PM_CheckMovingGround( clientdata_t *cd, entity_state_t *state, float frametime )
+static void CL_SetupPMove( playermove_t *pmove, const local_state_t *from, const usercmd_t *ucmd, qboolean runfuncs, double time )
 {
-	if(!( cd->flags & FL_BASEVELOCITY ))
+	const entity_state_t	*ps;
-	{
+	const clientdata_t	*cd;
-		// apply momentum (add in half of the previous frame of velocity first)
-		VectorMA( cd->velocity, 1.0f + (frametime * 0.5f), state->basevelocity, cd->velocity );
-		VectorClear( state->basevelocity );
-	}
-	cd->flags &= ~FL_BASEVELOCITY;
-}
-
-void CL_SetupPMove( playermove_t *pmove, local_state_t *from, usercmd_t *ucmd, qboolean runfuncs, double time )
-{
-	entity_state_t	*ps;
-	clientdata_t	*cd;
 
 	ps = &from->playerstate;
 	cd = &from->client;
@@ -993,22 +835,21 @@ void CL_SetupPMove( playermove_t *pmove, local_state_t *from, usercmd_t *ucmd, q
 	VectorCopy( ps->basevelocity, pmove->basevelocity );
 	VectorCopy( cd->view_ofs, pmove->view_ofs );
 	VectorClear( pmove->movedir );
-	pmove->flDuckTime = cd->flDuckTime;
+	pmove->flDuckTime = (float)cd->flDuckTime;
 	pmove->bInDuck = cd->bInDuck;
 	pmove->usehull = ps->usehull;
 	pmove->flTimeStepSound = cd->flTimeStepSound;
 	pmove->iStepLeft = ps->iStepLeft;
 	pmove->flFallVelocity = ps->flFallVelocity;
-	pmove->flSwimTime = cd->flSwimTime;
+	pmove->flSwimTime = (float)cd->flSwimTime;
 	VectorCopy( cd->punchangle, pmove->punchangle );
-	pmove->flSwimTime = cd->flSwimTime;
 	pmove->flNextPrimaryAttack = 0.0f; // not used by PM_ code
 	pmove->effects = ps->effects;
 	pmove->flags = cd->flags;
 	pmove->gravity = ps->gravity;
 	pmove->friction = ps->friction;
 	pmove->oldbuttons = ps->oldbuttons;
-	pmove->waterjumptime = cd->waterjumptime;
+	pmove->waterjumptime = (float)cd->waterjumptime;
 	pmove->dead = (cl.local.health <= 0);
 	pmove->deadflag = cd->deadflag;
 	pmove->spectator = (cls.spectator != 0);
@@ -1035,7 +876,7 @@ void CL_SetupPMove( playermove_t *pmove, local_state_t *from, usercmd_t *ucmd, q
 	Q_strncpy( pmove->physinfo, cls.physinfo, MAX_INFO_STRING );
 }
 
-void CL_FinishPMove( playermove_t *pmove, local_state_t *to )
+const void CL_FinishPMove( const playermove_t *pmove, local_state_t *to )
 {
 	entity_state_t	*ps;
 	clientdata_t	*cd;
@@ -1046,7 +887,7 @@ void CL_FinishPMove( playermove_t *pmove, local_state_t *to )
 	cd->flags = pmove->flags;
 	cd->bInDuck = pmove->bInDuck;
 	cd->flTimeStepSound = pmove->flTimeStepSound;
-	cd->flDuckTime = pmove->flDuckTime;
+	cd->flDuckTime = (int)pmove->flDuckTime;
 	cd->flSwimTime = (int)pmove->flSwimTime;
 	cd->waterjumptime = (int)pmove->waterjumptime;
 	cd->watertype = pmove->watertype;
@@ -1059,7 +900,7 @@ void CL_FinishPMove( playermove_t *pmove, local_state_t *to )
 	VectorCopy( pmove->angles, ps->angles );
 	VectorCopy( pmove->basevelocity, ps->basevelocity );
 	VectorCopy( pmove->punchangle, cd->punchangle );
-	ps->oldbuttons = pmove->oldbuttons;
+	ps->oldbuttons = (uint)pmove->cmd.buttons;
 	ps->friction = pmove->friction;
 	ps->movetype = pmove->movetype;
 	ps->onground = pmove->onground;
@@ -1091,13 +932,14 @@ Runs prediction code for user cmd
 void CL_RunUsercmd( local_state_t *from, local_state_t *to, usercmd_t *u, qboolean runfuncs, double *time, unsigned int random_seed )
 {
 	usercmd_t		cmd;
+
+	if( u->msec > 50 )
+	{
 		local_state_t	temp;
 		usercmd_t		split;
 
 		memset( &temp, 0, sizeof( temp ));
 
-	if( u->msec > 50 )
-	{
 		split = *u;
 		split.msec /= 2;
 		CL_RunUsercmd( from, &temp, &split, runfuncs, time, random_seed );
@@ -1164,15 +1006,11 @@ Sets cl.predicted.origin and cl.predicted.angles
 */
 void CL_PredictMovement( qboolean repredicting )
 {
-	runcmd_t		*to_cmd, *from_cmd;
+	runcmd_t		*to_cmd = NULL, *from_cmd;
 	local_state_t	*from = NULL, *to = NULL;
-	int		current_command;
-	int		current_command_mod;
 	frame_t *frame = NULL;
-	int		i, stoppoint;
+	uint		i, stoppoint;
-	qboolean		runfuncs;
 	double		f = 1.0;
-	cl_entity_t	*ent;
 	double		time;
 
 	if( cls.state != ca_active || cls.spectator )
@@ -1183,7 +1021,7 @@ void CL_PredictMovement( qboolean repredicting )
 
 	CL_SetUpPlayerPrediction( false, false );
 
-	if( cls.state != ca_active || !cl.validsequence )
+	if( !cl.validsequence )
 		return;
 
 	if(( cls.netchan.outgoing_sequence - cls.netchan.incoming_acknowledged ) >= CL_UPDATE_MASK )
@@ -1224,6 +1062,10 @@ void CL_PredictMovement( qboolean repredicting )
 
 	for( i = 1; i < CL_UPDATE_MASK && cls.netchan.incoming_acknowledged + i < cls.netchan.outgoing_sequence + stoppoint; i++ )
 	{
+		uint		current_command;
+		uint		current_command_mod;
+		qboolean		runfuncs;
+
 		current_command = cls.netchan.incoming_acknowledged + i;
 		current_command_mod = current_command & CL_UPDATE_MASK;
 
@@ -1238,10 +1080,6 @@ void CL_PredictMovement( qboolean repredicting )
 		if( to_cmd->senttime >= host.realtime )
 			break;
 
-		// now interpolate some fraction of the final frame
-		if( to_cmd->senttime != from_cmd->senttime )
-			f = (host.realtime - from_cmd->senttime) / (to_cmd->senttime - from_cmd->senttime) * 0.1;
-
 		from = to;
 		from_cmd = to_cmd;
 	}
@@ -1267,15 +1105,17 @@ void CL_PredictMovement( qboolean repredicting )
 			cl.local.onground = frame->playerstate[cl.playernum].onground;
 		else cl.local.onground = -1;
 
-		if( !repredicting || !CVAR_TO_BOOL( cl_lw ))
+		if( !repredicting || !cl_lw.value )
 			cl.local.viewmodel = to->client.viewmodel;
 		cl.local.repredicting = false;
 		cl.local.moving = false;
 		return;
 	}
 
-	f = bound( 0.0f, f, 1.0f );
+	// now interpolate some fraction of the final frame
-	f = 0.0;	// FIXME: make work, do revision
+	if( to_cmd->senttime != from_cmd->senttime )
+		f = bound( 0.0, (host.realtime - from_cmd->senttime) / (to_cmd->senttime - from_cmd->senttime) * 0.1, 1.0 );
+	else f = 0.0;
 
 	if( CL_PlayerTeleported( from, to ))
 	{
@@ -1297,12 +1137,12 @@ void CL_PredictMovement( qboolean repredicting )
 
 	cl.local.waterlevel = to->client.waterlevel;
 	cl.local.usehull = to->playerstate.usehull;
-	if( !repredicting || !CVAR_TO_BOOL( cl_lw ))
+	if( !repredicting || !cl_lw.value )
 		cl.local.viewmodel = to->client.viewmodel;
 
 	if( FBitSet( to->client.flags, FL_ONGROUND ))
 	{
-		ent = CL_GetEntityByIndex( cl.local.lastground );
+		cl_entity_t	*ent = CL_GetEntityByIndex( cl.local.lastground );
 		cl.local.onground = cl.local.lastground;
 		cl.local.moving = false;
 
@@ -1324,10 +1164,10 @@ void CL_PredictMovement( qboolean repredicting )
 	else
 	{
 		cl.local.onground = -1;
-		cl.local.moving = 0;
+		cl.local.moving = false;
 	}
 
-	if( cls.correction_time > 0 && !cl_nosmooth->value && cl_smoothtime->value )
+	if( cls.correction_time > 0 && !cl_nosmooth.value && cl_smoothtime.value )
 	{
 		vec3_t delta;
 		float frac;
@@ -1337,14 +1177,14 @@ void CL_PredictMovement( qboolean repredicting )
 			cls.correction_time -= host.frametime;
 
 		// Make sure smoothtime is postive
-		if( cl_smoothtime->value <= 0.0 )
+		if( cl_smoothtime.value <= 0.0f )
-			Cvar_DirectSet( cl_smoothtime, "0.1" );
+			Cvar_DirectSet( &cl_smoothtime, "0.1" );
 
 		// Clamp from 0 to cl_smoothtime.value
-		cls.correction_time = bound( 0.0, cls.correction_time, cl_smoothtime->value );
+		cls.correction_time = bound( 0.0, cls.correction_time, cl_smoothtime.value );
 
 		// Compute backward interpolation fraction along full correction
-		frac = 1.0 - cls.correction_time / cl_smoothtime->value;
+		frac = 1.0f - cls.correction_time / cl_smoothtime.value;
 
 		// Determine how much error we still have to make up for
 		VectorSubtract( cl.simorg, cl.local.lastorigin, delta );

engine/client/cl_qparse.c

@@ -17,7 +17,6 @@ GNU General Public License for more details.
 #include "client.h"
 #include "net_encode.h"
 #include "particledef.h"
-#include "gl_local.h"
 #include "cl_tent.h"
 #include "shake.h"
 #include "hltv.h"
@@ -86,7 +85,7 @@ static qboolean CL_QuakeEntityTeleported( cl_entity_t *ent, entity_state_t *news
 	VectorSubtract( newstate->origin, ent->prevstate.origin, delta );
 
 	// compute potential max movement in units per frame and compare with entity movement
-	maxlen = ( clgame.movevars.maxvelocity * ( 1.0 / GAME_FPS ));
+	maxlen = ( clgame.movevars.maxvelocity * ( 1.0f / GAME_FPS ));
 	len = VectorLength( delta );
 
 	return (len > maxlen);
@@ -233,14 +232,10 @@ static void CL_ParseQuakeServerInfo( sizebuf_t *msg )
 		// loading user settings
 		CSCR_LoadDefaultCVars( "user.scr" );
 
-		if( r_decals->value > mp_decals.value )
+		if( r_decals.value > mp_decals.value )
-			Cvar_SetValue( "r_decals", mp_decals.value );
+			Cvar_DirectSet( &r_decals, mp_decals.string );
 	}
-	else Cvar_Reset( "r_decals" );
+	else Cvar_DirectSet( &r_decals, NULL );
-
-	// re-init mouse
-	if( cl.background )
-		host.mouse_visible = false;
 
 	if( cl.background )	// tell the game parts about background state
 		Cvar_FullSet( "cl_background", "1", FCVAR_READ_ONLY );
@@ -263,7 +258,7 @@ static void CL_ParseQuakeServerInfo( sizebuf_t *msg )
 	Q_strncpy( gameui.globals->maptitle, clgame.maptitle, sizeof( gameui.globals->maptitle ));
 
 	if( !cls.changelevel && !cls.changedemo )
-		CL_InitEdicts (); // re-arrange edicts
+		CL_InitEdicts( cl.maxclients ); // re-arrange edicts
 
 	// Quake just have a large packet of initialization data
 	for( i = 1; i < MAX_MODELS; i++ )
@@ -303,13 +298,13 @@ static void CL_ParseQuakeServerInfo( sizebuf_t *msg )
 
 	// get splash name
 	if( cls.demoplayback && ( cls.demonum != -1 ))
-		Cvar_Set( "cl_levelshot_name", va( "levelshots/%s_%s", cls.demoname, glState.wideScreen ? "16x9" : "4x3" ));
+		Cvar_Set( "cl_levelshot_name", va( "levelshots/%s_%s", cls.demoname, refState.wideScreen ? "16x9" : "4x3" ));
-	else Cvar_Set( "cl_levelshot_name", va( "levelshots/%s_%s", clgame.mapname, glState.wideScreen ? "16x9" : "4x3" ));
+	else Cvar_Set( "cl_levelshot_name", va( "levelshots/%s_%s", clgame.mapname, refState.wideScreen ? "16x9" : "4x3" ));
 	Cvar_SetValue( "scr_loading", 0.0f ); // reset progress bar
 
-	if(( cl_allow_levelshots->value && !cls.changelevel ) || cl.background )
+	if(( cl_allow_levelshots.value && !cls.changelevel ) || cl.background )
 	{
-		if( !FS_FileExists( va( "%s.bmp", cl_levelshot_name->string ), true )) 
+		if( !FS_FileExists( va( "%s.bmp", cl_levelshot_name.string ), true ))
 			Cvar_Set( "cl_levelshot_name", "*black" ); // render a black screen
 		cls.scrshot_request = scrshot_plaque; // request levelshot even if exist (check filetime)
 	}
@@ -677,7 +672,7 @@ static void CL_ParseQuakeStaticEntity( sizebuf_t *msg )
 	if( ent->model != NULL )
 	{
 		// auto 'solid' faces
-		if( FBitSet( ent->model->flags, MODEL_TRANSPARENT ) && CL_IsQuakeCompatible( ))
+		if( FBitSet( ent->model->flags, MODEL_TRANSPARENT ) && Host_IsQuakeCompatible())
 		{
 			ent->curstate.rendermode = kRenderTransAlpha;
 			ent->curstate.renderamt = 255;
@@ -699,17 +694,13 @@ static void CL_ParseQuakeBaseline( sizebuf_t *msg )
 	cl_entity_t	*ent;
 	int		newnum;
 
-	memset( &state, 0, sizeof( state ));
 	newnum = MSG_ReadWord( msg ); // entnum
 
 	if( newnum >= clgame.maxEntities )
 		Host_Error( "CL_AllocEdict: no free edicts\n" );
 
-	ent = CL_EDICT_NUM( newnum );
-	memset( &ent->prevstate, 0, sizeof( ent->prevstate ));
-	ent->index = newnum;
-
 	// parse baseline
+	memset( &state, 0, sizeof( state ));
 	state.modelindex = MSG_ReadByte( msg );
 	state.frame = MSG_ReadByte( msg );
 	state.colormap = MSG_ReadByte( msg );
@@ -720,8 +711,10 @@ static void CL_ParseQuakeBaseline( sizebuf_t *msg )
 	state.angles[1] = MSG_ReadAngle( msg );
 	state.origin[2] = MSG_ReadCoord( msg );
 	state.angles[2] = MSG_ReadAngle( msg );
-	ent->player = CL_IsPlayerIndex( newnum );
 
+	ent = CL_EDICT_NUM( newnum );
+	ent->index = newnum;
+	ent->player = CL_IsPlayerIndex( newnum );
 	memcpy( &ent->baseline, &state, sizeof( entity_state_t ));
 	memcpy( &ent->prevstate, &state, sizeof( entity_state_t ));
 }
@@ -826,6 +819,9 @@ CL_QuakeStuffText
 void CL_QuakeStuffText( const char *text )
 {
 	Q_strncat( cmd_buf, text, sizeof( cmd_buf ));
+
+	// a1ba: didn't filtered, anyway quake protocol
+	// only supported for demos, not network games
 	Cbuf_AddText( text );
 }
 
@@ -862,9 +858,7 @@ void CL_QuakeExecStuff( void )
 
 		if( !*text ) break;
 
-		host.com_ignorebracket = true;
+		text = COM_ParseFileSafe( text, token, sizeof( token ), PFILE_IGNOREBRACKET, NULL, NULL );
-		text = COM_ParseFile( text, token );
-		host.com_ignorebracket = false;
 
 		if( !text ) break;
 

engine/client/cl_remap.c

@@ -15,7 +15,6 @@ GNU General Public License for more details.
 
 #include "common.h"
 #include "client.h"
-#include "gl_local.h"
 #include "studio.h"
 
 /*
@@ -42,11 +41,24 @@ CL_CmpStudioTextures
 return true if equal
 ====================
 */
-qboolean CL_CmpStudioTextures( int numtexs, mstudiotexture_t *p1, mstudiotexture_t *p2 )
+static qboolean CL_CmpStudioTextures( int numtexs, mstudiotexture_t *p1, remap_info_t *remap )
 {
 	int	i;
+	mstudiotexture_t *p2;
 
-	if( !p1 || !p2 ) return false;
+	if( !p1 ) // no textures
+		return false;
+
+	if( !remap ) // current model has no remap
+		return false;
+
+	if( !remap->textures ) // shouldn't happen, just in case
+		return false;
+
+	if( numtexs != remap->numtextures ) // amount of textures differs, it's a different model
+		return false;
+
+	p2 = remap->ptexture;
 
 	for( i = 0; i < numtexs; i++, p1++, p2++ )
 	{
@@ -78,7 +90,9 @@ byte *CL_CreateRawTextureFromPixels( texture_t *tx, size_t *size, int topcolor,
 	// fill header
 	if( !pin.name[0] ) Q_strncpy( pin.name, "#raw_remap_image.mdl", sizeof( pin.name ));
 	pin.flags = STUDIO_NF_COLORMAP; // just in case :-)
-	pin.index = (int)(tx + 1); // pointer to pixels
+	//pin.index = (int)(tx + 1); // pointer to pixels
+	// no more pointer-to-int-to-pointer casts
+	Image_SetMDLPointer( (byte*)((texture_t *)tx + 1) );
 	pin.width = tx->width;
 	pin.height = tx->height;
 
@@ -97,24 +111,25 @@ CL_DuplicateTexture
 Dupliacte texture with remap pixels
 ====================
 */
-void CL_DuplicateTexture( mstudiotexture_t *ptexture, int topcolor, int bottomcolor )
+void CL_DuplicateTexture( cl_entity_t *entity, model_t *model, mstudiotexture_t *ptexture, int topcolor, int bottomcolor )
 {
-	gl_texture_t	*glt;
+	const char *name;
 	texture_t		*tx = NULL;
 	char		texname[128];
-	int		i, size, index;
+	int		i, index;
+	size_t size;
 	byte		paletteBackup[768];
 	byte		*raw, *pal;
 
 	// save off the real texture index
 	index = ptexture->index;
-	glt = R_GetTexture( index );
+	name = ref.dllFuncs.GL_TextureName( index );
-	Q_snprintf( texname, sizeof( texname ), "#%i_%s", RI.currententity->curstate.number, glt->name + 1 );
+	Q_snprintf( texname, sizeof( texname ), "#%i_%s", entity->curstate.number, name + 1 );
 
 	// search for pixels
-	for( i = 0; i < RI.currentmodel->numtextures; i++ )
+	for( i = 0; i < model->numtextures; i++ )
 	{
-		tx = RI.currentmodel->textures[i];
+		tx = model->textures[i];
 		if( tx->gl_texturenum == index )
 			break; // found
 	}
@@ -126,7 +141,7 @@ void CL_DuplicateTexture( mstudiotexture_t *ptexture, int topcolor, int bottomco
 	memcpy( paletteBackup, pal, 768 );
 
 	raw = CL_CreateRawTextureFromPixels( tx, &size, topcolor, bottomcolor );
-	ptexture->index = GL_LoadTexture( texname, raw, size, TF_FORCE_COLOR ); // do copy
+	ptexture->index = ref.dllFuncs.GL_LoadTexture( texname, raw, size, TF_FORCE_COLOR ); // do copy
 
 	// restore original palette
 	memcpy( pal, paletteBackup, 768 );
@@ -139,32 +154,33 @@ CL_UpdateStudioTexture
 Update texture top and bottom colors
 ====================
 */
-void CL_UpdateStudioTexture( mstudiotexture_t *ptexture, int topcolor, int bottomcolor )
+void CL_UpdateStudioTexture( cl_entity_t *entity, mstudiotexture_t *ptexture, int topcolor, int bottomcolor )
 {
-	gl_texture_t	*glt;
 	rgbdata_t		*pic;
 	texture_t		*tx = NULL;
 	char		texname[128], name[128], mdlname[128];
-	int		i, size, index;
+	const char	*origtexname;
+	int		i, index;
+	size_t size;
 	byte		paletteBackup[768];
 	byte		*raw, *pal;
 
 	// save off the real texture index
-	glt = R_GetTexture( ptexture->index );
+	origtexname = ref.dllFuncs.GL_TextureName( ptexture->index );
 
 	// build name of original texture
-	Q_strncpy( mdlname, RI.currentmodel->name, sizeof( mdlname ));
+	Q_strncpy( mdlname, entity->model->name, sizeof( mdlname ));
-	COM_FileBase( ptexture->name, name );
+	COM_FileBase( ptexture->name, name, sizeof( name ));
 	COM_StripExtension( mdlname );
 
 	Q_snprintf( texname, sizeof( texname ), "#%s/%s.mdl", mdlname, name );
-	index = GL_FindTexture( texname );
+	index = ref.dllFuncs.GL_FindTexture( texname );
 	if( !index ) return; // couldn't find texture
 
 	// search for pixels
-	for( i = 0; i < RI.currentmodel->numtextures; i++ )
+	for( i = 0; i < entity->model->numtextures; i++ )
 	{
-		tx = RI.currentmodel->textures[i];
+		tx = entity->model->textures[i];
 		if( tx->gl_texturenum == index )
 			break; // found
 	}
@@ -176,14 +192,14 @@ void CL_UpdateStudioTexture( mstudiotexture_t *ptexture, int topcolor, int botto
 	memcpy( paletteBackup, pal, 768 );
 
 	raw = CL_CreateRawTextureFromPixels( tx, &size, topcolor, bottomcolor );
-	pic = FS_LoadImage( glt->name, raw, size );
+	pic = FS_LoadImage( origtexname, raw, size );
 	if( !pic )
 	{
-		Con_DPrintf( S_ERROR "Couldn't update texture %s\n", glt->name );
+		Con_DPrintf( S_ERROR "Couldn't update texture %s\n", origtexname );
 		return;
 	}
 
-	index = GL_UpdateTextureInternal( glt->name, pic, 0 );
+	index = GL_UpdateTextureInternal( origtexname, pic, 0 );
 	FS_FreeImage( pic );
 
 	// restore original palette
@@ -199,21 +215,21 @@ CL_UpdateAliasTexture
 Update texture top and bottom colors
 ====================
 */
-void CL_UpdateAliasTexture( unsigned short *texture, int skinnum, int topcolor, int bottomcolor )
+void CL_UpdateAliasTexture( cl_entity_t *entity, unsigned short *texture, int skinnum, int topcolor, int bottomcolor )
 {
 	char	texname[MAX_QPATH];
 	rgbdata_t	skin, *pic;
 	texture_t	*tx;
 
-	if( !texture || !RI.currentmodel->textures )
+	if( !texture || !entity->model->textures )
 		return; // no remapinfo in model
 
-	tx = RI.currentmodel->textures[skinnum];
+	tx = entity->model->textures[skinnum];
 	if( !tx ) return; // missing texture ?
 
 	if( *texture == 0 )
 	{
-		Q_snprintf( texname, sizeof( texname ), "%s:remap%i_%i", RI.currentmodel->name, skinnum, RI.currententity->index );
+		Q_snprintf( texname, sizeof( texname ), "%s:remap%i_%i", entity->model->name, skinnum, entity->index );
 		skin.width = tx->width;
 		skin.height = tx->height;
 		skin.depth = skin.numMips = 1;
@@ -228,7 +244,7 @@ void CL_UpdateAliasTexture( unsigned short *texture, int skinnum, int topcolor,
 	}
 
 	// and now we can remap with internal routines
-	GL_ProcessTexture( *texture, -1.0f, topcolor, bottomcolor );
+	ref.dllFuncs.GL_ProcessTexture( *texture, -1.0f, topcolor, bottomcolor );
 }
 
 /*
@@ -239,7 +255,7 @@ Allocate new remap info per entity
 and make copy of remap textures
 ====================
 */
-void CL_AllocRemapInfo( int topcolor, int bottomcolor )
+void CL_AllocRemapInfo( cl_entity_t *entity, model_t *model, int topcolor, int bottomcolor )
 {
 	remap_info_t	*info;
 	studiohdr_t	*phdr;
@@ -247,10 +263,10 @@ void CL_AllocRemapInfo( int topcolor, int bottomcolor )
 	mstudiotexture_t	*src, *dst;
 	int		i, size;
 
-	if( !RI.currententity ) return;
+	if( !entity ) return;
-	i = ( RI.currententity == &clgame.viewent ) ? clgame.maxEntities : RI.currententity->curstate.number;
+	i = ( entity == &clgame.viewent ) ? clgame.maxEntities : entity->curstate.number;
 
-	if( !RI.currentmodel || ( RI.currentmodel->type != mod_alias && RI.currentmodel->type != mod_studio ))
+	if( !model || ( model->type != mod_alias && model->type != mod_studio ))
 	{
 		// entity has changed model by another type, release remap info
 		if( clgame.remap_info[i] )
@@ -262,7 +278,7 @@ void CL_AllocRemapInfo( int topcolor, int bottomcolor )
 	}
 
 	// model doesn't contains remap textures
-	if( RI.currentmodel->numtextures <= 0 )
+	if( model->numtextures <= 0 )
 	{
 		// entity has changed model with no remap textures
 		if( clgame.remap_info[i] )
@@ -273,16 +289,15 @@ void CL_AllocRemapInfo( int topcolor, int bottomcolor )
 		return;
 	}
 
-	if( RI.currentmodel->type == mod_studio )
+	if( model->type == mod_studio )
 	{
-		phdr = (studiohdr_t *)Mod_StudioExtradata( RI.currentmodel );
+		phdr = (studiohdr_t *)Mod_StudioExtradata( model );
 		if( !phdr ) return;	// bad model?
 
 		src = (mstudiotexture_t *)(((byte *)phdr) + phdr->textureindex);
-		dst = (clgame.remap_info[i] ? clgame.remap_info[i]->ptexture : NULL); 
 
 		// NOTE: we must copy all the structures 'mstudiotexture_t' for easy access when model is rendering
-		if( !CL_CmpStudioTextures( phdr->numtextures, src, dst ) || clgame.remap_info[i]->model != RI.currentmodel )
+		if( !CL_CmpStudioTextures( phdr->numtextures, src, clgame.remap_info[i] ) || clgame.remap_info[i]->model != model )
 		{
 			// this code catches studiomodel change with another studiomodel with remap textures
 			// e.g. playermodel 'barney' with playermodel 'gordon'
@@ -311,16 +326,16 @@ void CL_AllocRemapInfo( int topcolor, int bottomcolor )
 		for( i = 0; i < info->numtextures; i++ )
 		{
 			if( dst[i].flags & STUDIO_NF_COLORMAP )
-				CL_DuplicateTexture( &dst[i], topcolor, bottomcolor );
+				CL_DuplicateTexture( entity, model, &dst[i], topcolor, bottomcolor );
 		}
 	}
-	else if( RI.currentmodel->type == mod_alias )
+	else if( model->type == mod_alias )
 	{
-		ahdr = (aliashdr_t *)Mod_AliasExtradata( RI.currentmodel );
+		ahdr = (aliashdr_t *)Mod_AliasExtradata( model );
 		if( !ahdr ) return;	// bad model?
 
 		// NOTE: we must copy all the structures 'mstudiotexture_t' for easy access when model is rendering
-		if( !clgame.remap_info[i] || clgame.remap_info[i]->model != RI.currentmodel )
+		if( !clgame.remap_info[i] || clgame.remap_info[i]->model != model )
 		{
 			// this code catches studiomodel change with another studiomodel with remap textures
 			// e.g. playermodel 'barney' with playermodel 'gordon'
@@ -333,10 +348,10 @@ void CL_AllocRemapInfo( int topcolor, int bottomcolor )
 			return;
 		}
 
-		info->numtextures = RI.currentmodel->numtextures;
+		info->numtextures = model->numtextures;
 
 		// alias remapping is easy
-		CL_UpdateRemapInfo( topcolor, bottomcolor );
+		CL_UpdateRemapInfo( entity, topcolor, bottomcolor );
 	}
 	else
 	{
@@ -344,7 +359,7 @@ void CL_AllocRemapInfo( int topcolor, int bottomcolor )
 		return;
 	}
 
-	info->model = RI.currentmodel;
+	info->model = model;
 }
 
 /*
@@ -354,12 +369,12 @@ CL_UpdateRemapInfo
 Update all remaps per entity
 ====================
 */
-void CL_UpdateRemapInfo( int topcolor, int bottomcolor )
+void CL_UpdateRemapInfo( cl_entity_t *entity, int topcolor, int bottomcolor )
 {
 	remap_info_t	*info;
 	int		i;
 
-	i = ( RI.currententity == &clgame.viewent ) ? clgame.maxEntities : RI.currententity->curstate.number;
+	i = ( entity == &clgame.viewent ) ? clgame.maxEntities : entity->curstate.number;
 	info = clgame.remap_info[i];
 	if( !info ) return; // no remap info
 
@@ -371,9 +386,9 @@ void CL_UpdateRemapInfo( int topcolor, int bottomcolor )
 		if( info->ptexture != NULL )
 		{
 			if( FBitSet( info->ptexture[i].flags, STUDIO_NF_COLORMAP ))
-				CL_UpdateStudioTexture( &info->ptexture[i], topcolor, bottomcolor );
+				CL_UpdateStudioTexture( entity, &info->ptexture[i], topcolor, bottomcolor );
 		}
-		else CL_UpdateAliasTexture( &info->textures[i], i, topcolor, bottomcolor );
+		else CL_UpdateAliasTexture( entity, &info->textures[i], i, topcolor, bottomcolor );
 	}
 
 	info->topcolor = topcolor;
@@ -399,11 +414,11 @@ void CL_FreeRemapInfo( remap_info_t *info )
 		if( info->ptexture != NULL )
 		{
 			if( FBitSet( info->ptexture[i].flags, STUDIO_NF_COLORMAP ))
-				GL_FreeTexture( info->ptexture[i].index );
+				ref.dllFuncs.GL_FreeTexture( info->ptexture[i].index );
 		}
 
 		if( info->textures[i] != 0 )
-			GL_FreeTexture( info->textures[i] );
+			ref.dllFuncs.GL_FreeTexture( info->textures[i] );
 	}
 
 	Mem_Free( info ); // release struct

engine/client/cl_render.c

@@ -0,0 +1,354 @@
+/*
+cl_render.c - RenderAPI loader & implementation
+Copyright (C) 2019 a1batross
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+*/
+
+#include "common.h"
+#include "client.h"
+#include "library.h"
+#include "platform/platform.h"
+
+int R_FatPVS( const vec3_t org, float radius, byte *visbuffer, qboolean merge, qboolean fullvis )
+{
+	return Mod_FatPVS( org, radius, visbuffer, world.visbytes, merge, fullvis );
+}
+
+lightstyle_t *CL_GetLightStyle( int number )
+{
+	Assert( number >= 0 && number < MAX_LIGHTSTYLES );
+	return &cl.lightstyles[number];
+}
+
+const ref_overview_t *GL_GetOverviewParms( void )
+{
+	return &clgame.overView;
+}
+
+static void *R_Mem_Alloc( size_t cb, const char *filename, const int fileline )
+{
+	return _Mem_Alloc( cls.mempool, cb, true, filename, fileline );
+}
+
+static void R_Mem_Free( void *mem, const char *filename, const int fileline )
+{
+	if( !mem ) return;
+	_Mem_Free( mem, filename, fileline );
+}
+
+/*
+=========
+pfnGetFilesList
+
+=========
+*/
+static char **pfnGetFilesList( const char *pattern, int *numFiles, int gamedironly )
+{
+	static search_t	*t = NULL;
+
+	if( t ) Mem_Free( t ); // release prev search
+
+	t = FS_Search( pattern, true, gamedironly );
+
+	if( !t )
+	{
+		if( numFiles ) *numFiles = 0;
+		return NULL;
+	}
+
+	if( numFiles ) *numFiles = t->numfilenames;
+	return t->filenames;
+}
+
+static uint pfnFileBufferCRC32( const void *buffer, const int length )
+{
+	uint	modelCRC = 0;
+
+	if( !buffer || length <= 0 )
+		return modelCRC;
+
+	CRC32_Init( &modelCRC );
+	CRC32_ProcessBuffer( &modelCRC, buffer, length );
+	return CRC32_Final( modelCRC );
+}
+
+/*
+=================
+R_EnvShot
+
+=================
+*/
+static void R_EnvShot( const float *vieworg, const char *name, qboolean skyshot, int shotsize )
+{
+	static vec3_t viewPoint;
+
+	if( !COM_CheckString( name ))
+		return;
+
+	if( cls.scrshot_action != scrshot_inactive )
+	{
+		if( cls.scrshot_action != scrshot_skyshot && cls.scrshot_action != scrshot_envshot )
+			Con_Printf( S_ERROR "R_%sShot: subsystem is busy, try for next frame.\n", skyshot ? "Sky" : "Env" );
+		return;
+	}
+
+	cls.envshot_vieworg = NULL; // use client view
+	Q_strncpy( cls.shotname, name, sizeof( cls.shotname ));
+
+	if( vieworg )
+	{
+		// make sure what viewpoint don't temporare
+		VectorCopy( vieworg, viewPoint );
+		cls.envshot_vieworg = viewPoint;
+		cls.envshot_disable_vis = true;
+	}
+
+	// make request for envshot
+	if( skyshot ) cls.scrshot_action = scrshot_skyshot;
+	else cls.scrshot_action = scrshot_envshot;
+
+	// catch negative values
+	cls.envshot_viewsize = Q_max( 0, shotsize );
+}
+
+/*
+=============
+CL_GenericHandle
+
+=============
+*/
+const char *CL_GenericHandle( int fileindex )
+{
+	if( fileindex < 0 || fileindex >= MAX_CUSTOM )
+		return 0;
+	return cl.files_precache[fileindex];
+}
+
+intptr_t CL_RenderGetParm( const int parm, const int arg, const qboolean checkRef )
+{
+	switch( parm )
+	{
+	case PARM_BSP2_SUPPORTED:
+#ifdef SUPPORT_BSP2_FORMAT
+		return 1;
+#endif
+		return 0;
+	case PARM_SKY_SPHERE:
+		return FBitSet( world.flags, FWORLD_SKYSPHERE ) && !FBitSet( world.flags, FWORLD_CUSTOM_SKYBOX );
+	case PARAM_GAMEPAUSED:
+		return cl.paused;
+	case PARM_CLIENT_INGAME:
+		return CL_IsInGame();
+	case PARM_MAX_ENTITIES:
+		return clgame.maxEntities;
+	case PARM_FEATURES:
+		return host.features;
+	case PARM_MAP_HAS_DELUXE:
+		return FBitSet( world.flags, FWORLD_HAS_DELUXEMAP );
+	case PARM_CLIENT_ACTIVE:
+		return (cls.state == ca_active);
+	case PARM_DEDICATED_SERVER:
+		return (host.type == HOST_DEDICATED);
+	case PARM_WATER_ALPHA:
+		return FBitSet( world.flags, FWORLD_WATERALPHA );
+	case PARM_DELUXEDATA:
+		return (intptr_t)world.deluxedata;
+	case PARM_SHADOWDATA:
+		return (intptr_t)world.shadowdata;
+	case PARM_FULLSCREEN:
+		return refState.fullScreen;
+	case PARM_WIDESCREEN:
+		return refState.wideScreen;
+	case PARM_SCREEN_WIDTH:
+		return refState.width;
+	case PARM_SCREEN_HEIGHT:
+		return refState.height;
+	default:
+		// indicates call from client.dll
+		if( checkRef )
+		{
+			return ref.dllFuncs.RefGetParm( parm, arg );
+		}
+		// call issued from ref_dll, check extensions here
+		else switch( parm )
+		{
+		case PARM_DEV_OVERVIEW:
+			return CL_IsDevOverviewMode();
+		case PARM_THIRDPERSON:
+			return CL_IsThirdPerson();
+		case PARM_QUAKE_COMPATIBLE:
+			return Host_IsQuakeCompatible();
+		case PARM_PLAYER_INDEX:
+			return cl.playernum + 1;
+		case PARM_VIEWENT_INDEX:
+			return cl.viewentity;
+		case PARM_CONNSTATE:
+			return (int)cls.state;
+		case PARM_PLAYING_DEMO:
+			return cls.demoplayback;
+		case PARM_WATER_LEVEL:
+			return cl.local.waterlevel;
+		case PARM_MAX_CLIENTS:
+			return cl.maxclients;
+		case PARM_LOCAL_HEALTH:
+			return cl.local.health;
+		case PARM_LOCAL_GAME:
+			return Host_IsLocalGame();
+		case PARM_NUMENTITIES:
+			return pfnNumberOfEntities();
+		case PARM_NUMMODELS:
+			return cl.nummodels;
+		}
+	}
+	return 0;
+}
+
+static intptr_t pfnRenderGetParm( int parm, int arg )
+{
+	return CL_RenderGetParm( parm, arg, true );
+}
+
+static render_api_t gRenderAPI =
+{
+	pfnRenderGetParm, // GL_RenderGetParm,
+	NULL, // R_GetDetailScaleForTexture,
+	NULL, // R_GetExtraParmsForTexture,
+	CL_GetLightStyle,
+	CL_GetDynamicLight,
+	CL_GetEntityLight,
+	LightToTexGamma,
+	NULL, // R_GetFrameTime,
+	NULL, // R_SetCurrentEntity,
+	NULL, // R_SetCurrentModel,
+	R_FatPVS,
+	R_StoreEfrags,
+	NULL, // GL_FindTexture,
+	NULL, // GL_TextureName,
+	NULL, // GL_TextureData,
+	NULL, // GL_LoadTexture,
+	NULL, // GL_CreateTexture,
+	NULL, // GL_LoadTextureArray,
+	NULL, // GL_CreateTextureArray,
+	NULL, // GL_FreeTexture,
+	NULL, // DrawSingleDecal,
+	NULL, // R_DecalSetupVerts,
+	NULL, // R_EntityRemoveDecals,
+	(void*)AVI_LoadVideo,
+	(void*)AVI_GetVideoInfo,
+	(void*)AVI_GetVideoFrameNumber,
+	(void*)AVI_GetVideoFrame,
+	NULL, // R_UploadStretchRaw,
+	(void*)AVI_FreeVideo,
+	(void*)AVI_IsActive,
+	S_StreamAviSamples,
+	NULL,
+	NULL,
+	NULL, // GL_Bind,
+	NULL, // GL_SelectTexture,
+	NULL, // GL_LoadTexMatrixExt,
+	NULL, // GL_LoadIdentityTexMatrix,
+	NULL, // GL_CleanUpTextureUnits,
+	NULL, // GL_TexGen,
+	NULL, // GL_TextureTarget,
+	NULL, // GL_SetTexCoordArrayMode,
+	NULL, // GL_GetProcAddress,
+	NULL, // GL_UpdateTexSize,
+	NULL,
+	NULL,
+	NULL, // CL_DrawParticlesExternal,
+	R_EnvShot,
+	pfnSPR_LoadExt,
+	NULL, // R_LightVec,
+	NULL, // R_StudioGetTexture,
+	GL_GetOverviewParms,
+	CL_GenericHandle,
+	COM_SaveFile,
+	NULL,
+	R_Mem_Alloc,
+	R_Mem_Free,
+	pfnGetFilesList,
+	pfnFileBufferCRC32,
+	COM_CompareFileTime,
+	Host_Error,
+	(void*)CL_ModelHandle,
+	pfnTime,
+	Cvar_Set,
+	S_FadeMusicVolume,
+	COM_SetRandomSeed,
+};
+
+static void R_FillRenderAPIFromRef( render_api_t *to, const ref_interface_t *from )
+{
+	to->GetDetailScaleForTexture = from->GetDetailScaleForTexture;
+	to->GetExtraParmsForTexture  = from->GetExtraParmsForTexture;
+	to->GetFrameTime             = from->GetFrameTime;
+	to->R_SetCurrentEntity       = from->R_SetCurrentEntity;
+	to->R_SetCurrentModel        = from->R_SetCurrentModel;
+	to->GL_FindTexture           = from->GL_FindTexture;
+	to->GL_TextureName           = from->GL_TextureName;
+	to->GL_TextureData           = from->GL_TextureData;
+	to->GL_LoadTexture           = from->GL_LoadTexture;
+	to->GL_CreateTexture         = from->GL_CreateTexture;
+	to->GL_LoadTextureArray      = from->GL_LoadTextureArray;
+	to->GL_CreateTextureArray    = from->GL_CreateTextureArray;
+	to->GL_FreeTexture           = from->GL_FreeTexture;
+	to->DrawSingleDecal          = from->DrawSingleDecal;
+	to->R_DecalSetupVerts        = from->R_DecalSetupVerts;
+	to->R_EntityRemoveDecals     = from->R_EntityRemoveDecals;
+	to->AVI_UploadRawFrame       = from->AVI_UploadRawFrame;
+	to->GL_Bind                  = from->GL_Bind;
+	to->GL_SelectTexture         = from->GL_SelectTexture;
+	to->GL_LoadTextureMatrix     = from->GL_LoadTextureMatrix;
+	to->GL_TexMatrixIdentity     = from->GL_TexMatrixIdentity;
+	to->GL_CleanUpTextureUnits   = from->GL_CleanUpTextureUnits;
+	to->GL_TexGen                = from->GL_TexGen;
+	to->GL_TextureTarget         = from->GL_TextureTarget;
+	to->GL_TexCoordArrayMode     = from->GL_TexCoordArrayMode;
+	to->GL_UpdateTexSize         = from->GL_UpdateTexSize;
+	to->GL_DrawParticles         = from->GL_DrawParticles;
+	to->LightVec                 = from->LightVec;
+	to->StudioGetTexture         = from->StudioGetTexture;
+	to->GL_GetProcAddress        = from->R_GetProcAddress;
+}
+
+/*
+===============
+R_InitRenderAPI
+
+Initialize client external rendering
+===============
+*/
+qboolean R_InitRenderAPI( void )
+{
+	// make sure what render functions is cleared
+	memset( &clgame.drawFuncs, 0, sizeof( clgame.drawFuncs ));
+
+	// fill missing functions from renderer
+	R_FillRenderAPIFromRef( &gRenderAPI, &ref.dllFuncs );
+
+	if( clgame.dllFuncs.pfnGetRenderInterface )
+	{
+		if( clgame.dllFuncs.pfnGetRenderInterface( CL_RENDER_INTERFACE_VERSION, &gRenderAPI, &clgame.drawFuncs ))
+		{
+			Con_Reportf( "CL_LoadProgs: ^2initailized extended RenderAPI ^7ver. %i\n", CL_RENDER_INTERFACE_VERSION );
+			return true;
+		}
+
+		// make sure what render functions is cleared
+		memset( &clgame.drawFuncs, 0, sizeof( clgame.drawFuncs ));
+
+		return false; // just tell user about problems
+	}
+
+	// render interface is missed
+	return true;
+}

engine/client/cl_scrn.c

@@ -15,20 +15,23 @@ GNU General Public License for more details.
 
 #include "common.h"
 #include "client.h"
-#include "gl_local.h"
 #include "vgui_draw.h"
 #include "qfont.h"
 #include "input.h"
+#include "library.h"
 
-convar_t *scr_centertime;
+CVAR_DEFINE_AUTO( scr_centertime, "2.5", 0, "centerprint hold time" );
-convar_t *scr_loading;
+CVAR_DEFINE_AUTO( scr_loading, "0", 0, "loading bar progress" );
-convar_t *scr_download;
+CVAR_DEFINE_AUTO( scr_download, "-1", 0, "downloading bar progress" );
-convar_t *scr_viewsize;
+CVAR_DEFINE( scr_viewsize, "viewsize", "120", FCVAR_ARCHIVE, "screen size (quake only)" );
-convar_t *cl_testlights;
+CVAR_DEFINE_AUTO( cl_testlights, "0", 0, "test dynamic lights" );
-convar_t *cl_allow_levelshots;
+CVAR_DEFINE( cl_allow_levelshots, "allow_levelshots", "0", FCVAR_ARCHIVE, "allow engine to use indivdual levelshots instead of 'loading' image" );
-convar_t *cl_levelshot_name;
+CVAR_DEFINE_AUTO( cl_levelshot_name, "*black", 0, "contains path to current levelshot" );
-convar_t *cl_envshot_size;
+static CVAR_DEFINE_AUTO( cl_envshot_size, "256", FCVAR_ARCHIVE, "envshot size of cube side" );
-convar_t *v_dark;
+CVAR_DEFINE_AUTO( v_dark, "0", 0, "starts level from dark screen" );
+static CVAR_DEFINE_AUTO( net_speeds, "0", FCVAR_ARCHIVE, "show network packets" );
+static CVAR_DEFINE_AUTO( cl_showfps, "0", FCVAR_ARCHIVE, "show client fps" );
+static CVAR_DEFINE_AUTO( cl_showpos, "0", FCVAR_ARCHIVE, "show local player position and velocity" );
 
 typedef struct
 {
@@ -56,7 +59,7 @@ void SCR_DrawFPS( int height )
 	char		fpsstring[64];
 	int		offset;
 
-	if( cls.state != ca_active || !cl_showfps->value || cl.background )
+	if( cls.state != ca_active || !cl_showfps.value || cl.background )
 		return;
 
 	switch( cls.scrshot_action )
@@ -92,14 +95,49 @@ void SCR_DrawFPS( int height )
 		if( curfps < minfps ) minfps = curfps;
 		if( curfps > maxfps ) maxfps = curfps;
 
-		if( cl_showfps->value == 2 )
+		if( cl_showfps.value == 2 )
 			Q_snprintf( fpsstring, sizeof( fpsstring ), "fps: ^1%4i min, ^3%4i cur, ^2%4i max", minfps, curfps, maxfps );
 		else Q_snprintf( fpsstring, sizeof( fpsstring ), "%4i fps", curfps );
 		MakeRGBA( color, 255, 255, 255, 255 );
 	}
 
 	Con_DrawStringLen( fpsstring, &offset, NULL );
-	Con_DrawString( glState.width - offset - 4, height, fpsstring, color );
+	Con_DrawString( refState.width - offset - 4, height, fpsstring, color );
+}
+
+/*
+==============
+SCR_DrawPos
+
+Draw local player position, angles and velocity
+==============
+*/
+void SCR_DrawPos( void )
+{
+	static char     msg[MAX_SYSPATH];
+	float speed;
+	cl_entity_t *ent;
+	rgba_t color;
+
+	if( cls.state != ca_active || !cl_showpos.value || cl.background )
+		return;
+
+	ent = CL_GetLocalPlayer();
+	speed = VectorLength( cl.simvel );
+
+	Q_snprintf( msg, MAX_SYSPATH,
+		"pos: %.2f %.2f %.2f\n"
+		"ang: %.2f %.2f %.2f\n"
+		"velocity: %.2f",
+		cl.simorg[0], cl.simorg[1], cl.simorg[2],
+		// should we use entity angles or viewangles?
+		// view isn't always bound to player
+		ent->angles[0], ent->angles[1], ent->angles[2],
+		speed );
+
+	MakeRGBA( color, 255, 255, 255, 255 );
+
+	Con_DrawString( refState.width / 2, 4, msg, color );
 }
 
 /*
@@ -112,8 +150,7 @@ same as r_speeds but for network channel
 void SCR_NetSpeeds( void )
 {
 	static char	msg[MAX_SYSPATH];
-	int		x, y, height;
+	int		x, y;
-	char		*p, *start, *end;
 	float		time = cl.mtime[0];
 	static int	min_svfps = 100;
 	static int	max_svfps = 0;
@@ -122,11 +159,12 @@ void SCR_NetSpeeds( void )
 	static int	max_clfps = 0;
 	int		cur_clfps = 0;
 	rgba_t		color;
+	cl_font_t *font = Con_GetCurFont();
 
 	if( !host.allow_console )
 		return;
 
-	if( !net_speeds->value || cls.state != ca_active )
+	if( !net_speeds.value || cls.state != ca_active )
 		return;
 
 	// prevent to get too big values at max
@@ -145,28 +183,24 @@ void SCR_NetSpeeds( void )
 		if( cur_clfps > max_clfps ) max_clfps = cur_clfps;
 	}
 
-	Q_snprintf( msg, sizeof( msg ), "sv fps: ^1%4i min, ^3%4i cur, ^2%4i max\ncl fps: ^1%4i min, ^3%4i cur, ^2%4i max\nGame Time: %02d:%02d\nTotal received from server: %s\nTotal sent to server: %s\n",
+	Q_snprintf( msg, sizeof( msg ),
-	min_svfps, cur_svfps, max_svfps, min_clfps, cur_clfps, max_clfps, (int)(time / 60.0f ), (int)fmod( time, 60.0f ), Q_memprint( cls.netchan.total_received ), Q_memprint( cls.netchan.total_sended ));
+		"Updaterate: ^1%2i min, ^3%2i cur, ^2%2i max\n"
+		"Client FPS: ^1%i min, ^3%3i cur, ^2%3i max\n"
+		"Game Time: %02d:%02d\n"
+		"Total received from server: %s\n"
+		"Total sent to server: %s\n",
+		min_svfps, cur_svfps, max_svfps,
+		min_clfps, cur_clfps, max_clfps,
+		(int)(time / 60.0f ), (int)fmod( time, 60.0f ),
+		Q_memprint( cls.netchan.total_received ),
+		Q_memprint( cls.netchan.total_sended )
+	);
 
-	x = glState.width - 320;
+	x = refState.width - 320 * font->scale;
 	y = 384;
 
-	Con_DrawStringLen( NULL, NULL, &height );
 	MakeRGBA( color, 255, 255, 255, 255 );
-
+	CL_DrawString( x, y, msg, color, font, FONT_DRAW_RESETCOLORONLF );
-	p = start = msg;
-
-	do
-	{
-		end = Q_strchr( p, '\n' );
-		if( end ) msg[end-start] = '\0';
-
-		Con_DrawString( x, y, p, color );
-		y += height;
-
-		if( end ) p = end + 1;
-		else break;
-	} while( 1 );
 }
 
 /*
@@ -181,33 +215,17 @@ void SCR_RSpeeds( void )
 	if( !host.allow_console )
 		return;
 
-	if( R_SpeedsMessage( msg, sizeof( msg )))
+	if( ref.dllFuncs.R_SpeedsMessage( msg, sizeof( msg )))
 	{
-		int	x, y, height;
+		int	x, y;
-		char	*p, *start, *end;
 		rgba_t	color;
+		cl_font_t *font = Con_GetCurFont();
 
-		x = glState.width - 340;
+		x = refState.width - 340 * font->scale;
 		y = 64;
 
-		Con_DrawStringLen( NULL, NULL, &height );
 		MakeRGBA( color, 255, 255, 255, 255 );
-
+		CL_DrawString( x, y, msg, color, font, FONT_DRAW_RESETCOLORONLF );
-		p = start = msg;
-		do
-		{
-			end = Q_strchr( p, '\n' );
-			if( end ) msg[end-start] = '\0';
-
-			Con_DrawString( x, y, p, color );
-			y += height;
-
-			// handle '\n\n'
-			if( *p == '\n' ) 
-				y += height;
-			if( end ) p = end + 1;
-			else break;
-		} while( 1 );
 	}
 }
 
@@ -227,6 +245,37 @@ void SCR_MakeLevelShot( void )
 	Cbuf_AddText( "levelshot\n" );
 }
 
+/*
+===============
+VID_WriteOverviewScript
+
+Create overview script file
+===============
+*/
+void VID_WriteOverviewScript( void )
+{
+	ref_overview_t	*ov = &clgame.overView;
+	string		filename;
+	file_t		*f;
+
+	Q_snprintf( filename, sizeof( filename ), "overviews/%s.txt", clgame.mapname );
+
+	f = FS_Open( filename, "w", false );
+	if( !f ) return;
+
+	FS_Printf( f, "// overview description file for %s.bsp\n\n", clgame.mapname );
+	FS_Print( f, "global\n{\n" );
+	FS_Printf( f, "\tZOOM\t%.2f\n", ov->flZoom );
+	FS_Printf( f, "\tORIGIN\t%.2f\t%.2f\t%.2f\n", ov->origin[0], ov->origin[1], ov->origin[2] );
+	FS_Printf( f, "\tROTATED\t%i\n", ov->rotated ? 1 : 0 );
+	FS_Print( f, "}\n\nlayer\n{\n" );
+	FS_Printf( f, "\tIMAGE\t\"overviews/%s.bmp\"\n", clgame.mapname );
+	FS_Printf( f, "\tHEIGHT\t%.2f\n", ov->zFar );	// ???
+	FS_Print( f, "}\n" );
+
+	FS_Close( f );
+}
+
 /*
 ================
 SCR_MakeScreenShot
@@ -241,30 +290,32 @@ void SCR_MakeScreenShot( void )
 
 	if( cls.envshot_viewsize > 0 )
 		viewsize = cls.envshot_viewsize;
-	else viewsize = cl_envshot_size->value;
+	else viewsize = cl_envshot_size.value;
 
 	switch( cls.scrshot_action )
 	{
 	case scrshot_normal:
-		iRet = VID_ScreenShot( cls.shotname, VID_SCREENSHOT );
+		iRet = ref.dllFuncs.VID_ScreenShot( cls.shotname, VID_SCREENSHOT );
 		break;
 	case scrshot_snapshot:
-		iRet = VID_ScreenShot( cls.shotname, VID_SNAPSHOT );
+		iRet = ref.dllFuncs.VID_ScreenShot( cls.shotname, VID_SNAPSHOT );
 		break;
 	case scrshot_plaque:
-		iRet = VID_ScreenShot( cls.shotname, VID_LEVELSHOT );
+		iRet = ref.dllFuncs.VID_ScreenShot( cls.shotname, VID_LEVELSHOT );
 		break;
 	case scrshot_savegame:
-		iRet = VID_ScreenShot( cls.shotname, VID_MINISHOT );
+		iRet = ref.dllFuncs.VID_ScreenShot( cls.shotname, VID_MINISHOT );
 		break;
 	case scrshot_envshot:
-		iRet = VID_CubemapShot( cls.shotname, viewsize, cls.envshot_vieworg, false );
+		iRet = ref.dllFuncs.VID_CubemapShot( cls.shotname, viewsize, cls.envshot_vieworg, false );
 		break;
 	case scrshot_skyshot:
-		iRet = VID_CubemapShot( cls.shotname, viewsize, cls.envshot_vieworg, true );
+		iRet = ref.dllFuncs.VID_CubemapShot( cls.shotname, viewsize, cls.envshot_vieworg, true );
 		break;
 	case scrshot_mapshot:
-		iRet = VID_ScreenShot( cls.shotname, VID_MAPSHOT );
+		iRet = ref.dllFuncs.VID_ScreenShot( cls.shotname, VID_MAPSHOT );
+		if( iRet )
+			VID_WriteOverviewScript(); // store overview script too
 		break;
 	case scrshot_inactive:
 		return;
@@ -293,11 +344,11 @@ SCR_DrawPlaque
 */
 void SCR_DrawPlaque( void )
 {
-	if(( cl_allow_levelshots->value && !cls.changelevel ) || cl.background )
+	if(( cl_allow_levelshots.value && !cls.changelevel ) || cl.background )
 	{
-		int levelshot = GL_LoadTexture( cl_levelshot_name->string, NULL, 0, TF_IMAGE );
+		int levelshot = ref.dllFuncs.GL_LoadTexture( cl_levelshot_name.string, NULL, 0, TF_IMAGE );
-		GL_SetRenderMode( kRenderNormal );
+		ref.dllFuncs.GL_SetRenderMode( kRenderNormal );
-		R_DrawStretchPic( 0, 0, glState.width, glState.height, 0, 0, 1, 1, levelshot );
+		ref.dllFuncs.R_DrawStretchPic( 0, 0, refState.width, refState.height, 0, 0, 1, 1, levelshot );
 		if( !cl.background ) CL_DrawHUD( CL_LOADING );
 	}
 }
@@ -309,17 +360,18 @@ SCR_BeginLoadingPlaque
 */
 void SCR_BeginLoadingPlaque( qboolean is_background )
 {
-	float	oldclear;
+	float	oldclear = 0;;
-
 	S_StopAllSounds( true );
 	cl.audio_prepped = false;			// don't play ambients
 	cl.video_prepped = false;
-	oldclear = gl_clear->value;
+
+	if( !Host_IsDedicated() )
+		oldclear = gl_clear.value;
 
 	if( CL_IsInMenu( ) && !cls.changedemo && !is_background )
 	{
 		UI_SetActiveMenu( false );
-		if( cls.state == ca_disconnected )
+		if( cls.state == ca_disconnected && !(GameState->curstate == STATE_RUNFRAME && GameState->nextstate != STATE_RUNFRAME) )
 			SCR_UpdateScreen();
 	}
 
@@ -329,14 +381,18 @@ void SCR_BeginLoadingPlaque( qboolean is_background )
 	if( cls.key_dest == key_console )
 		return;
 
-	gl_clear->value = 0.0f;
+	if( !Host_IsDedicated() )
+		gl_clear.value = 0.0f;
+
 	if( is_background ) IN_MouseSavePos( );
 	cls.draw_changelevel = !is_background;
 	SCR_UpdateScreen();
 	cls.disable_screen = host.realtime;
-	cls.disable_servercount = cl.servercount;
 	cl.background = is_background;		// set right state before svc_serverdata is came
-	gl_clear->value = oldclear;
+
+	if( !Host_IsDedicated() )
+		gl_clear.value = oldclear;
+
 //	SNDDMA_LockSound();
 }
 
@@ -373,7 +429,7 @@ SCR_DirtyScreen
 void SCR_DirtyScreen( void )
 {
 	SCR_AddDirtyPoint( 0, 0 );
-	SCR_AddDirtyPoint( glState.width - 1, glState.height - 1 );
+	SCR_AddDirtyPoint( refState.width - 1, refState.height - 1 );
 }
 
 /*
@@ -386,7 +442,7 @@ void SCR_TileClear( void )
 	int	i, top, bottom, left, right;
 	dirty_t	clear;
 
-	if( scr_viewsize->value >= 120 )
+	if( scr_viewsize.value >= 120 )
 		return; // full screen rendering
 
 	// erase rect will be the union of the past three frames
@@ -425,7 +481,7 @@ void SCR_TileClear( void )
 	{
 		// clear above view screen
 		i = clear.y2 < top-1 ? clear.y2 : top - 1;
-		R_DrawTileClear( clear.x1, clear.y1, clear.x2 - clear.x1 + 1, i - clear.y1 + 1 );
+		ref.dllFuncs.R_DrawTileClear( cls.tileImage, clear.x1, clear.y1, clear.x2 - clear.x1 + 1, i - clear.y1 + 1 );
 		clear.y1 = top;
 	}
 
@@ -433,7 +489,7 @@ void SCR_TileClear( void )
 	{
 		// clear below view screen
 		i = clear.y1 > bottom + 1 ? clear.y1 : bottom + 1;
-		R_DrawTileClear( clear.x1, i, clear.x2 - clear.x1 + 1, clear.y2 - i + 1 );
+		ref.dllFuncs.R_DrawTileClear( cls.tileImage, clear.x1, i, clear.x2 - clear.x1 + 1, clear.y2 - i + 1 );
 		clear.y2 = bottom;
 	}
 
@@ -441,7 +497,7 @@ void SCR_TileClear( void )
 	{
 		// clear left of view screen
 		i = clear.x2 < left - 1 ? clear.x2 : left - 1;
-		R_DrawTileClear( clear.x1, clear.y1, i - clear.x1 + 1, clear.y2 - clear.y1 + 1 );
+		ref.dllFuncs.R_DrawTileClear( cls.tileImage, clear.x1, clear.y1, i - clear.x1 + 1, clear.y2 - clear.y1 + 1 );
 		clear.x1 = left;
 	}
 
@@ -449,7 +505,7 @@ void SCR_TileClear( void )
 	{
 		// clear left of view screen
 		i = clear.x1 > right + 1 ? clear.x1 : right + 1;
-		R_DrawTileClear( i, clear.y1, clear.x2 - i + 1, clear.y2 - clear.y1 + 1 );
+		ref.dllFuncs.R_DrawTileClear( cls.tileImage, i, clear.y1, clear.x2 - i + 1, clear.y2 - clear.y1 + 1 );
 		clear.x2 = right;
 	}
 }
@@ -491,77 +547,6 @@ void SCR_UpdateScreen( void )
 	V_PostRender();
 }
 
-qboolean SCR_LoadFixedWidthFont( const char *fontname )
-{
-	int	i, fontWidth;
-
-	if( cls.creditsFont.valid )
-		return true; // already loaded
-
-	if( !FS_FileExists( fontname, false ))
-		return false;
-
-	cls.creditsFont.hFontTexture = GL_LoadTexture( fontname, NULL, 0, TF_IMAGE|TF_KEEP_SOURCE );
-	R_GetTextureParms( &fontWidth, NULL, cls.creditsFont.hFontTexture );
-	cls.creditsFont.charHeight = clgame.scrInfo.iCharHeight = fontWidth / 16;
-	cls.creditsFont.type = FONT_FIXED;
-	cls.creditsFont.valid = true;
-
-	// build fixed rectangles
-	for( i = 0; i < 256; i++ )
-	{
-		cls.creditsFont.fontRc[i].left = (i * (fontWidth / 16)) % fontWidth;
-		cls.creditsFont.fontRc[i].right = cls.creditsFont.fontRc[i].left + fontWidth / 16;
-		cls.creditsFont.fontRc[i].top = (i / 16) * (fontWidth / 16);
-		cls.creditsFont.fontRc[i].bottom = cls.creditsFont.fontRc[i].top + fontWidth / 16;
-		cls.creditsFont.charWidths[i] = clgame.scrInfo.charWidths[i] = fontWidth / 16;
-	}
-
-	return true;
-}
-
-qboolean SCR_LoadVariableWidthFont( const char *fontname )
-{
-	int	i, fontWidth;
-	byte	*buffer;
-	size_t	length;
-	qfont_t	*src;
-
-	if( cls.creditsFont.valid )
-		return true; // already loaded
-
-	if( !FS_FileExists( fontname, false ))
-		return false;
-
-	cls.creditsFont.hFontTexture = GL_LoadTexture( fontname, NULL, 0, TF_IMAGE );
-	R_GetTextureParms( &fontWidth, NULL, cls.creditsFont.hFontTexture );
-
-	// half-life font with variable chars witdh
-	buffer = FS_LoadFile( fontname, &length, false );
-
-	// setup creditsfont	
-	if( buffer && length >= sizeof( qfont_t ))
-	{
-		src = (qfont_t *)buffer;
-		cls.creditsFont.charHeight = clgame.scrInfo.iCharHeight = src->rowheight;
-		cls.creditsFont.type = FONT_VARIABLE;
-
-		// build rectangles
-		for( i = 0; i < 256; i++ )
-		{
-			cls.creditsFont.fontRc[i].left = (word)src->fontinfo[i].startoffset % fontWidth;
-			cls.creditsFont.fontRc[i].right = cls.creditsFont.fontRc[i].left + src->fontinfo[i].charwidth;
-			cls.creditsFont.fontRc[i].top = (word)src->fontinfo[i].startoffset / fontWidth;
-			cls.creditsFont.fontRc[i].bottom = cls.creditsFont.fontRc[i].top + src->rowheight;
-			cls.creditsFont.charWidths[i] = clgame.scrInfo.charWidths[i] = src->fontinfo[i].charwidth;
-		}
-		cls.creditsFont.valid = true;
-	}
-	if( buffer ) Mem_Free( buffer );
-
-	return true;
-}
-
 /*
 ================
 SCR_LoadCreditsFont
@@ -571,13 +556,43 @@ INTERNAL RESOURCE
 */
 void SCR_LoadCreditsFont( void )
 {
-	if( !SCR_LoadVariableWidthFont( "gfx.wad/creditsfont.fnt" ))
+	cl_font_t *const font = &cls.creditsFont;
+	qboolean success = false;
+	float scale = hud_fontscale.value;
+	dword crc = 0;
+
+	// replace default gfx.wad textures by current charset's font
+	if( !CRC32_File( &crc, "gfx.wad" ) || crc == 0x49eb9f16 )
 	{
-		if( !SCR_LoadFixedWidthFont( "gfx/conchars" ))
+		string charsetFnt;
-			Con_DPrintf( S_ERROR "failed to load HUD font\n" );
+
+		if( Q_snprintf( charsetFnt, sizeof( charsetFnt ),
+			"creditsfont_%s.fnt", Cvar_VariableString( "con_charset" )) > 0 )
+		{
+			if( FS_FileExists( charsetFnt, false ))
+				success = Con_LoadVariableWidthFont( charsetFnt, font, scale, kRenderTransAdd, TF_FONT );
 		}
 	}
 
+	if( !success )
+		success = Con_LoadVariableWidthFont( "gfx/creditsfont.fnt", font, scale, kRenderTransAdd, TF_FONT );
+
+	if( !success )
+		success = Con_LoadFixedWidthFont( "gfx/conchars", font, scale, kRenderTransAdd, TF_FONT );
+
+	// copy font size for client.dll
+	if( success )
+	{
+		int i;
+
+		clgame.scrInfo.iCharHeight = cls.creditsFont.charHeight;
+
+		for( i = 0; i < ARRAYSIZE( cls.creditsFont.charWidths ); i++ )
+			clgame.scrInfo.charWidths[i] = cls.creditsFont.charWidths[i];
+	}
+	else Con_DPrintf( S_ERROR "failed to load HUD font\n" );
+}
+
 /*
 ================
 SCR_InstallParticlePalette
@@ -631,24 +646,24 @@ void SCR_RegisterTextures( void )
 	// register gfx.wad images
 
 	if( FS_FileExists( "gfx/paused.lmp", false ))
-		cls.pauseIcon = GL_LoadTexture( "gfx/paused.lmp", NULL, 0, TF_IMAGE );
+		cls.pauseIcon = ref.dllFuncs.GL_LoadTexture( "gfx/paused.lmp", NULL, 0, TF_IMAGE );
 	else if( FS_FileExists( "gfx/pause.lmp", false ))
-		cls.pauseIcon = GL_LoadTexture( "gfx/pause.lmp", NULL, 0, TF_IMAGE );
+		cls.pauseIcon = ref.dllFuncs.GL_LoadTexture( "gfx/pause.lmp", NULL, 0, TF_IMAGE );
 
 	if( FS_FileExists( "gfx/lambda.lmp", false ))
 	{
-		if( cl_allow_levelshots->value )
+		if( cl_allow_levelshots.value )
-			cls.loadingBar = GL_LoadTexture( "gfx/lambda.lmp", NULL, 0, TF_IMAGE|TF_LUMINANCE );
+			cls.loadingBar = ref.dllFuncs.GL_LoadTexture( "gfx/lambda.lmp", NULL, 0, TF_IMAGE|TF_LUMINANCE );
-		else cls.loadingBar = GL_LoadTexture( "gfx/lambda.lmp", NULL, 0, TF_IMAGE ); 
+		else cls.loadingBar = ref.dllFuncs.GL_LoadTexture( "gfx/lambda.lmp", NULL, 0, TF_IMAGE );
 	}
 	else if( FS_FileExists( "gfx/loading.lmp", false ))
 	{
-		if( cl_allow_levelshots->value )
+		if( cl_allow_levelshots.value )
-			cls.loadingBar = GL_LoadTexture( "gfx/loading.lmp", NULL, 0, TF_IMAGE|TF_LUMINANCE );
+			cls.loadingBar = ref.dllFuncs.GL_LoadTexture( "gfx/loading.lmp", NULL, 0, TF_IMAGE|TF_LUMINANCE );
-		else cls.loadingBar = GL_LoadTexture( "gfx/loading.lmp", NULL, 0, TF_IMAGE ); 
+		else cls.loadingBar = ref.dllFuncs.GL_LoadTexture( "gfx/loading.lmp", NULL, 0, TF_IMAGE );
 	}
 
-	cls.tileImage = GL_LoadTexture( "gfx/backtile.lmp", NULL, 0, TF_NOMIPMAP );
+	cls.tileImage = ref.dllFuncs.GL_LoadTexture( "gfx/backtile.lmp", NULL, 0, TF_NOMIPMAP );
 }
 
 /*
@@ -660,7 +675,7 @@ Keybinding command
 */
 void SCR_SizeUp_f( void )
 {
-	Cvar_SetValue( "viewsize", Q_min( scr_viewsize->value + 10, 120 ));
+	Cvar_SetValue( "viewsize", Q_min( scr_viewsize.value + 10, 120 ));
 }
 
 
@@ -673,7 +688,7 @@ Keybinding command
 */
 void SCR_SizeDown_f( void )
 {
-	Cvar_SetValue( "viewsize", Q_max( scr_viewsize->value - 10, 30 ));
+	Cvar_SetValue( "viewsize", Q_max( scr_viewsize.value - 10, 30 ));
 }
 
 /*
@@ -683,15 +698,25 @@ SCR_VidInit
 */
 void SCR_VidInit( void )
 {
+	if( !ref.initialized ) // don't call VidInit too soon
+		return;
+
 	memset( &clgame.ds, 0, sizeof( clgame.ds )); // reset a draw state
 	memset( &gameui.ds, 0, sizeof( gameui.ds )); // reset a draw state
 	memset( &clgame.centerPrint, 0, sizeof( clgame.centerPrint ));
 
 	// update screen sizes for menu
-	gameui.globals->scrWidth = glState.width;
+	if( gameui.globals )
-	gameui.globals->scrHeight = glState.height;
+	{
+		gameui.globals->scrWidth = refState.width;
+		gameui.globals->scrHeight = refState.height;
+	}
 
-	VGui_Startup ();
+	// notify vgui about screen size change
+	if( clgame.hInstance )
+	{
+		VGui_Startup( refState.width, refState.height );
+	}
 
 	CL_ClearSpriteTextures(); // now all hud sprites are invalid
 
@@ -701,6 +726,7 @@ void SCR_VidInit( void )
 
 	// restart console size
 	Con_VidInit ();
+	Touch_NotifyResize();
 }
 
 /*
@@ -712,18 +738,20 @@ void SCR_Init( void )
 {
 	if( scr_init ) return;
 
-	scr_centertime = Cvar_Get( "scr_centertime", "2.5", 0, "centerprint hold time" );
+	Cvar_RegisterVariable( &scr_centertime );
-	cl_levelshot_name = Cvar_Get( "cl_levelshot_name", "*black", 0, "contains path to current levelshot" );
+	Cvar_RegisterVariable( &cl_levelshot_name );
-	cl_allow_levelshots = Cvar_Get( "allow_levelshots", "0", FCVAR_ARCHIVE, "allow engine to use indivdual levelshots instead of 'loading' image" );
+	Cvar_RegisterVariable( &cl_allow_levelshots );
-	scr_loading = Cvar_Get( "scr_loading", "0", 0, "loading bar progress" );
+	Cvar_RegisterVariable( &scr_loading );
-	scr_download = Cvar_Get( "scr_download", "-1", 0, "downloading bar progress" );
+	Cvar_RegisterVariable( &scr_download );
-	cl_testlights = Cvar_Get( "cl_testlights", "0", 0, "test dynamic lights" );
+	Cvar_RegisterVariable( &cl_testlights );
-	cl_envshot_size = Cvar_Get( "cl_envshot_size", "256", FCVAR_ARCHIVE, "envshot size of cube side" );
+	Cvar_RegisterVariable( &cl_envshot_size );
-	v_dark = Cvar_Get( "v_dark", "0", 0, "starts level from dark screen" );
+	Cvar_RegisterVariable( &v_dark );
-	scr_viewsize = Cvar_Get( "viewsize", "120", FCVAR_ARCHIVE, "screen size" );
+	Cvar_RegisterVariable( &scr_viewsize );
+	Cvar_RegisterVariable( &net_speeds );
+	Cvar_RegisterVariable( &cl_showfps );
+	Cvar_RegisterVariable( &cl_showpos );
 
 	// register our commands
-	Cmd_AddCommand( "timerefresh", SCR_TimeRefresh_f, "turn quickly and print rendering statistcs" );
 	Cmd_AddCommand( "skyname", CL_SetSky_f, "set new skybox by basename" );
 	Cmd_AddCommand( "loadsky", CL_SetSky_f, "set new skybox by basename" );
 	Cmd_AddCommand( "viewpos", SCR_Viewpos_f, "prints current player origin" );
@@ -732,7 +760,7 @@ void SCR_Init( void )
 
 	if( !UI_LoadProgs( ))
 	{
-		Con_Printf( S_ERROR "can't initialize gameui.dll\n" ); // there is non fatal for us
+		Con_Printf( S_ERROR "can't initialize gameui DLL: %s\n", COM_GetLibraryError() ); // there is non fatal for us
 		host.allow_console = true; // we need console, because menu is missing
 	}
 

engine/client/cl_securedstub.c

@@ -0,0 +1,463 @@
+/*
+cl_securedstub.c - secured client dll stub
+Copyright (C) 2022 FWGS
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+*/
+
+#include "common.h"
+#include "client.h"
+
+typedef struct cldll_func_src_s
+{
+	int	(*pfnInitialize)( cl_enginefunc_t *pEnginefuncs, int iVersion );
+	void	(*pfnInit)( void );
+	int	(*pfnVidInit)( void );
+	int	(*pfnRedraw)( float flTime, int intermission );
+	int	(*pfnUpdateClientData)( client_data_t *cdata, float flTime );
+	void	(*pfnReset)( void );
+	void	(*pfnPlayerMove)( struct playermove_s *ppmove, int server );
+	void	(*pfnPlayerMoveInit)( struct playermove_s *ppmove );
+	char	(*pfnPlayerMoveTexture)( char *name );
+	void	(*IN_ActivateMouse)( void );
+	void	(*IN_DeactivateMouse)( void );
+	void	(*IN_MouseEvent)( int mstate );
+	void	(*IN_ClearStates)( void );
+	void	(*IN_Accumulate)( void );
+	void	(*CL_CreateMove)( float frametime, struct usercmd_s *cmd, int active );
+	int	(*CL_IsThirdPerson)( void );
+	void	(*CL_CameraOffset)( float *ofs );	// unused
+	void	*(*KB_Find)( const char *name );
+	void	(*CAM_Think)( void );		// camera stuff
+	void	(*pfnCalcRefdef)( ref_params_t *pparams );
+	int	(*pfnAddEntity)( int type, cl_entity_t *ent, const char *modelname );
+	void	(*pfnCreateEntities)( void );
+	void	(*pfnDrawNormalTriangles)( void );
+	void	(*pfnDrawTransparentTriangles)( void );
+	void	(*pfnStudioEvent)( const struct mstudioevent_s *event, const cl_entity_t *entity );
+	void	(*pfnPostRunCmd)( struct local_state_s *from, struct local_state_s *to, usercmd_t *cmd, int runfuncs, double time, unsigned int random_seed );
+	void	(*pfnShutdown)( void );
+	void	(*pfnTxferLocalOverrides)( entity_state_t *state, const clientdata_t *client );
+	void	(*pfnProcessPlayerState)( entity_state_t *dst, const entity_state_t *src );
+	void	(*pfnTxferPredictionData)( entity_state_t *ps, const entity_state_t *pps, clientdata_t *pcd, const clientdata_t *ppcd, weapon_data_t *wd, const weapon_data_t *pwd );
+	void	(*pfnDemo_ReadBuffer)( int size, byte *buffer );
+	int	(*pfnConnectionlessPacket)( const struct netadr_s *net_from, const char *args, char *buffer, int *size );
+	int	(*pfnGetHullBounds)( int hullnumber, float *mins, float *maxs );
+	void	(*pfnFrame)( double time );
+	int	(*pfnKey_Event)( int eventcode, int keynum, const char *pszCurrentBinding );
+	void	(*pfnTempEntUpdate)( double frametime, double client_time, double cl_gravity, struct tempent_s **ppTempEntFree, struct tempent_s **ppTempEntActive, int ( *Callback_AddVisibleEntity )( cl_entity_t *pEntity ), void ( *Callback_TempEntPlaySound )( struct tempent_s *pTemp, float damp ));
+	cl_entity_t *(*pfnGetUserEntity)( int index );
+	void	(*pfnVoiceStatus)( int entindex, qboolean bTalking );
+	void	(*pfnDirectorMessage)( int iSize, void *pbuf );
+	int	(*pfnGetStudioModelInterface)( int version, struct r_studio_interface_s **ppinterface, struct engine_studio_api_s *pstudio );
+	void	(*pfnChatInputPosition)( int *x, int *y );
+	int	(*pfnGetPlayerTeam)( int iPlayer );
+	void	*(*pfnClientFactory)( void );
+} cldll_func_src_t;
+
+typedef struct cldll_func_dst_s
+{
+	void	(*pfnInitialize)( cl_enginefunc_t **pEnginefuncs, int *iVersion );
+	void	(*pfnInit)( void );
+	void	(*pfnVidInit)( void );
+	void	(*pfnRedraw)( float *flTime, int *intermission );
+	void	(*pfnUpdateClientData)( client_data_t **cdata, float *flTime );
+	void	(*pfnReset)( void );
+	void	(*pfnPlayerMove)( struct playermove_s **ppmove, int *server );
+	void	(*pfnPlayerMoveInit)( struct playermove_s **ppmove );
+	void	(*pfnPlayerMoveTexture)( char **name );
+	void	(*IN_ActivateMouse)( void );
+	void	(*IN_DeactivateMouse)( void );
+	void	(*IN_MouseEvent)( int *mstate );
+	void	(*IN_ClearStates)( void );
+	void	(*IN_Accumulate)( void );
+	void	(*CL_CreateMove)( float *frametime, struct usercmd_s **cmd, int *active );
+	void	(*CL_IsThirdPerson)( void );
+	void	(*CL_CameraOffset)( float **ofs );
+	void	(*KB_Find)( const char **name );
+	void	(*CAM_Think)( void );
+	void	(*pfnCalcRefdef)( ref_params_t **pparams );
+	void	(*pfnAddEntity)( int *type, cl_entity_t **ent, const char **modelname );
+	void	(*pfnCreateEntities)( void );
+	void	(*pfnDrawNormalTriangles)( void );
+	void	(*pfnDrawTransparentTriangles)( void );
+	void	(*pfnStudioEvent)( const struct mstudioevent_s **event, const cl_entity_t **entity );
+	void	(*pfnPostRunCmd)( struct local_state_s **from, struct local_state_s **to, usercmd_t **cmd, int *runfuncs, double *time, unsigned int *random_seed );
+	void	(*pfnShutdown)( void );
+	void	(*pfnTxferLocalOverrides)( entity_state_t **state, const clientdata_t **client );
+	void	(*pfnProcessPlayerState)( entity_state_t **dst, const entity_state_t **src );
+	void	(*pfnTxferPredictionData)( entity_state_t **ps, const entity_state_t **pps, clientdata_t **pcd, const clientdata_t **ppcd, weapon_data_t **wd, const weapon_data_t **pwd );
+	void	(*pfnDemo_ReadBuffer)( int *size, byte **buffer );
+	void	(*pfnConnectionlessPacket)( const struct netadr_s **net_from, const char **args, char **buffer, int **size );
+	void	(*pfnGetHullBounds)( int *hullnumber, float **mins, float **maxs );
+	void	(*pfnFrame)( double *time );
+	void	(*pfnKey_Event)( int *eventcode, int *keynum, const char **pszCurrentBinding );
+	void	(*pfnTempEntUpdate)( double *frametime, double *client_time, double *cl_gravity, struct tempent_s ***ppTempEntFree, struct tempent_s ***ppTempEntActive, int ( **Callback_AddVisibleEntity )( cl_entity_t *pEntity ), void ( **Callback_TempEntPlaySound )( struct tempent_s *pTemp, float damp ));
+	void	(*pfnGetUserEntity)( int *index );
+	void	(*pfnVoiceStatus)( int *entindex, qboolean *bTalking );
+	void	(*pfnDirectorMessage)( int *iSize, void **pbuf );
+	void	(*pfnGetStudioModelInterface)( int *version, struct r_studio_interface_s ***ppinterface, struct engine_studio_api_s **pstudio );
+	void	(*pfnChatInputPosition)( int **x, int **y );
+	void	(*pfnGetPlayerTeam)( int *iPlayer );
+} cldll_func_dst_t;
+
+struct cl_enginefunc_dst_s;
+struct modshelpers_s;
+struct modchelpers_s;
+struct engdata_s;
+
+typedef struct modfuncs_s
+{
+	void	(*m_pfnLoadMod)( char *pchModule );
+	void	(*m_pfnCloseMod)( void );
+	int	(*m_pfnNCall)( int ijump, int cnArg, ... );
+	void	(*m_pfnGetClDstAddrs)( cldll_func_dst_t *pcldstAddrs );
+	void	(*m_pfnGetEngDstAddrs)( struct cl_enginefunc_dst_s *pengdstAddrs );
+	void	(*m_pfnModuleLoaded)( void );
+	void	(*m_pfnProcessOutgoingNet)( struct netchan_s *pchan, struct sizebuf_s *psizebuf );
+	qboolean	(*m_pfnProcessIncomingNet)( struct netchan_s *pchan, struct sizebuf_s *psizebuf );
+	void	(*m_pfnTextureLoad)( char *pszName, int dxWidth, int dyHeight, char *pbData );
+	void	(*m_pfnModelLoad)( struct model_s *pmodel, void *pvBuf );
+	void	(*m_pfnFrameBegin)( void );
+	void	(*m_pfnFrameRender1)( void );
+	void	(*m_pfnFrameRender2)( void );
+	void	(*m_pfnSetModSHelpers)( struct modshelpers_s *pmodshelpers );
+	void	(*m_pfnSetModCHelpers)( struct modchelpers_s *pmodchelpers );
+	void	(*m_pfnSetEngData)( struct engdata_s *pengdata );
+	int	m_nVersion;
+	void	(*m_pfnConnectClient)( int iPlayer );
+	void	(*m_pfnRecordIP)( unsigned int pnIP );
+	void	(*m_pfnPlayerStatus)( unsigned char *pbData, int cbData );
+	void	(*m_pfnSetEngineVersion)( int nVersion );
+	int	m_nVoid2;
+	int	m_nVoid3;
+	int	m_nVoid4;
+	int	m_nVoid5;
+	int	m_nVoid6;
+	int	m_nVoid7;
+	int	m_nVoid8;
+	int	m_nVoid9;
+} modfuncs_t;
+
+static void DstInitialize( cl_enginefunc_t **pEnginefuncs, int *iVersion )
+{
+    // stub
+}
+
+static void DstInit( void )
+{
+    // stub
+}
+
+static void DstVidInit( void )
+{
+    // stub
+}
+
+static void DstRedraw( float *flTime, int *intermission )
+{
+    // stub
+}
+
+static void DstUpdateClientData( client_data_t **cdata, float *flTime )
+{
+    // stub
+}
+
+static void DstReset( void )
+{
+    // stub
+}
+
+static void DstPlayerMove( struct playermove_s **ppmove, int *server )
+{
+    // stub
+}
+
+static void DstPlayerMoveInit( struct playermove_s **ppmove )
+{
+    // stub
+}
+
+static void DstPlayerMoveTexture( char **name )
+{
+    // stub
+}
+
+static void DstIN_ActivateMouse( void )
+{
+    // stub
+}
+
+static void DstIN_DeactivateMouse( void )
+{
+    // stub
+}
+
+static void DstIN_MouseEvent( int *mstate )
+{
+    // stub
+}
+
+static void DstIN_ClearStates( void )
+{
+    // stub
+}
+
+static void DstIN_Accumulate( void )
+{
+    // stub
+}
+
+static void DstCL_CreateMove( float *frametime, struct usercmd_s **cmd, int *active )
+{
+    // stub
+}
+
+static void DstCL_IsThirdPerson( void )
+{
+    // stub
+}
+
+static void DstCL_CameraOffset( float **ofs )
+{
+    // stub
+}
+
+static void DstKB_Find( const char **name )
+{
+    // stub
+}
+
+static void DstCAM_Think( void )
+{
+    // stub
+}
+
+static void DstCalcRefdef( ref_params_t **pparams )
+{
+    // stub
+}
+
+static void DstAddEntity( int *type, cl_entity_t **ent, const char **modelname )
+{
+    // stub
+}
+
+static void DstCreateEntities( void )
+{
+    // stub
+}
+
+static void DstDrawNormalTriangles( void )
+{
+    // stub
+}
+
+static void DstDrawTransparentTriangles( void )
+{
+    // stub
+}
+
+static void DstStudioEvent( const struct mstudioevent_s **event, const cl_entity_t **entity )
+{
+    // stub
+}
+
+static void DstPostRunCmd( struct local_state_s **from, struct local_state_s **to, usercmd_t **cmd, int *runfuncs, double *time, unsigned int *random_seed )
+{
+    // stub
+}
+
+static void DstShutdown( void )
+{
+    // stub
+}
+
+static void DstTxferLocalOverrides( entity_state_t **state, const clientdata_t **client )
+{
+    // stub
+}
+
+static void DstProcessPlayerState( entity_state_t **dst, const entity_state_t **src )
+{
+    // stub
+}
+
+static void DstTxferPredictionData( entity_state_t **ps, const entity_state_t **pps, clientdata_t **pcd, const clientdata_t **ppcd, weapon_data_t **wd, const weapon_data_t **pwd )
+{
+    // stub
+}
+
+static void DstDemo_ReadBuffer( int *size, byte **buffer )
+{
+    // stub
+}
+
+static void DstConnectionlessPacket( const struct netadr_s **net_from, const char **args, char **buffer, int **size )
+{
+    // stub
+}
+
+static void DstGetHullBounds( int *hullnumber, float **mins, float **maxs )
+{
+    // stub
+}
+
+static void DstFrame( double *time )
+{
+    // stub
+}
+
+static void DstKey_Event( int *eventcode, int *keynum, const char **pszCurrentBinding )
+{
+    // stub
+}
+
+static void DstTempEntUpdate( double *frametime, double *client_time, double *cl_gravity, struct tempent_s ***ppTempEntFree, struct tempent_s ***ppTempEntActive, int ( **Callback_AddVisibleEntity )( cl_entity_t *pEntity ), void ( **Callback_TempEntPlaySound )( struct tempent_s *pTemp, float damp ) )
+{
+    // stub
+}
+
+static void DstGetUserEntity( int *index )
+{
+    // stub
+}
+
+static void DstVoiceStatus( int *entindex, qboolean *bTalking )
+{
+    // stub
+}
+
+static void DstDirectorMessage( int *iSize, void **pbuf )
+{
+    // stub
+}
+
+static void DstGetStudioModelInterface( int *version, struct r_studio_interface_s ***ppinterface, struct engine_studio_api_s **pstudio )
+{
+    // stub
+}
+
+static void DstChatInputPosition( int **x, int **y )
+{
+    // stub
+}
+
+static void DstGetPlayerTeam( int *iPlayer )
+{
+    // stub
+}
+
+static cldll_func_dst_t cldllFuncDst =
+{
+	DstInitialize,
+	DstInit,
+	DstVidInit,
+	DstRedraw,
+	DstUpdateClientData,
+	DstReset,
+	DstPlayerMove,
+	DstPlayerMoveInit,
+	DstPlayerMoveTexture,
+	DstIN_ActivateMouse,
+	DstIN_DeactivateMouse,
+	DstIN_MouseEvent,
+	DstIN_ClearStates,
+	DstIN_Accumulate,
+	DstCL_CreateMove,
+	DstCL_IsThirdPerson,
+	DstCL_CameraOffset,
+	DstKB_Find,
+	DstCAM_Think,
+	DstCalcRefdef,
+	DstAddEntity,
+	DstCreateEntities,
+	DstDrawNormalTriangles,
+	DstDrawTransparentTriangles,
+	DstStudioEvent,
+	DstPostRunCmd,
+	DstShutdown,
+	DstTxferLocalOverrides,
+	DstProcessPlayerState,
+	DstTxferPredictionData,
+	DstDemo_ReadBuffer,
+	DstConnectionlessPacket,
+	DstGetHullBounds,
+	DstFrame,
+	DstKey_Event,
+	DstTempEntUpdate,
+	DstGetUserEntity,
+	DstVoiceStatus,
+	DstDirectorMessage,
+	DstGetStudioModelInterface,
+	DstChatInputPosition,
+	DstGetPlayerTeam,
+};
+
+void CL_GetSecuredClientAPI( CL_EXPORT_FUNCS F )
+{
+	modfuncs_t modFuncs = { 0 };
+
+	// secured client dlls need these
+	cldll_func_src_t cldllFuncSrc =
+	{
+		(void *)&modFuncs,
+		NULL,
+		(void *)&cldllFuncDst
+	};
+
+	// trying to fill interface now
+	F( &cldllFuncSrc );
+
+	// map exports to xash's cldll_func_t
+	clgame.dllFuncs.pfnInitialize = cldllFuncSrc.pfnInitialize;
+	clgame.dllFuncs.pfnInit = cldllFuncSrc.pfnInit;
+	clgame.dllFuncs.pfnVidInit = cldllFuncSrc.pfnVidInit;
+	clgame.dllFuncs.pfnRedraw = cldllFuncSrc.pfnRedraw;
+	clgame.dllFuncs.pfnUpdateClientData = cldllFuncSrc.pfnUpdateClientData;
+	clgame.dllFuncs.pfnReset = cldllFuncSrc.pfnReset;
+	clgame.dllFuncs.pfnPlayerMove = cldllFuncSrc.pfnPlayerMove;
+	clgame.dllFuncs.pfnPlayerMoveInit = cldllFuncSrc.pfnPlayerMoveInit;
+	clgame.dllFuncs.pfnPlayerMoveTexture = cldllFuncSrc.pfnPlayerMoveTexture;
+	clgame.dllFuncs.IN_ActivateMouse = cldllFuncSrc.IN_ActivateMouse;
+	clgame.dllFuncs.IN_DeactivateMouse = cldllFuncSrc.IN_DeactivateMouse;
+	clgame.dllFuncs.IN_MouseEvent = cldllFuncSrc.IN_MouseEvent;
+	clgame.dllFuncs.IN_ClearStates = cldllFuncSrc.IN_ClearStates;
+	clgame.dllFuncs.IN_Accumulate = cldllFuncSrc.IN_Accumulate;
+	clgame.dllFuncs.CL_CreateMove = cldllFuncSrc.CL_CreateMove;
+	clgame.dllFuncs.CL_IsThirdPerson = cldllFuncSrc.CL_IsThirdPerson;
+	clgame.dllFuncs.CL_CameraOffset = cldllFuncSrc.CL_CameraOffset;
+	clgame.dllFuncs.KB_Find = cldllFuncSrc.KB_Find;
+	clgame.dllFuncs.CAM_Think = cldllFuncSrc.CAM_Think;
+	clgame.dllFuncs.pfnCalcRefdef = cldllFuncSrc.pfnCalcRefdef;
+	clgame.dllFuncs.pfnAddEntity = cldllFuncSrc.pfnAddEntity;
+	clgame.dllFuncs.pfnCreateEntities = cldllFuncSrc.pfnCreateEntities;
+	clgame.dllFuncs.pfnDrawNormalTriangles = cldllFuncSrc.pfnDrawNormalTriangles;
+	clgame.dllFuncs.pfnDrawTransparentTriangles = cldllFuncSrc.pfnDrawTransparentTriangles;
+	clgame.dllFuncs.pfnStudioEvent = cldllFuncSrc.pfnStudioEvent;
+	clgame.dllFuncs.pfnPostRunCmd = cldllFuncSrc.pfnPostRunCmd;
+	clgame.dllFuncs.pfnShutdown = cldllFuncSrc.pfnShutdown;
+	clgame.dllFuncs.pfnTxferLocalOverrides = cldllFuncSrc.pfnTxferLocalOverrides;
+	clgame.dllFuncs.pfnProcessPlayerState = cldllFuncSrc.pfnProcessPlayerState;
+	clgame.dllFuncs.pfnTxferPredictionData = cldllFuncSrc.pfnTxferPredictionData;
+	clgame.dllFuncs.pfnDemo_ReadBuffer = cldllFuncSrc.pfnDemo_ReadBuffer;
+	clgame.dllFuncs.pfnConnectionlessPacket = cldllFuncSrc.pfnConnectionlessPacket;
+	clgame.dllFuncs.pfnGetHullBounds = cldllFuncSrc.pfnGetHullBounds;
+	clgame.dllFuncs.pfnFrame = cldllFuncSrc.pfnFrame;
+	clgame.dllFuncs.pfnKey_Event = cldllFuncSrc.pfnKey_Event;
+	clgame.dllFuncs.pfnTempEntUpdate = cldllFuncSrc.pfnTempEntUpdate;
+	clgame.dllFuncs.pfnGetUserEntity = cldllFuncSrc.pfnGetUserEntity;
+	clgame.dllFuncs.pfnVoiceStatus = cldllFuncSrc.pfnVoiceStatus;
+	clgame.dllFuncs.pfnDirectorMessage = cldllFuncSrc.pfnDirectorMessage;
+	clgame.dllFuncs.pfnGetStudioModelInterface = cldllFuncSrc.pfnGetStudioModelInterface;
+	clgame.dllFuncs.pfnChatInputPosition = cldllFuncSrc.pfnChatInputPosition;
+}

engine/client/cl_tent.c

@@ -20,7 +20,6 @@ GNU General Public License for more details.
 #include "triangleapi.h"
 #include "cl_tent.h"
 #include "pm_local.h"
-#include "gl_local.h"
 #include "studio.h"
 #include "wadfile.h"	// acess decal size
 #include "sound.h"
@@ -151,7 +150,7 @@ void CL_AddClientResources( void )
 	int	i;
 
 	// don't request resources from localhost or in quake-compatibility mode
-	if( cl.maxclients <= 1 || CL_IsQuakeCompatible( ))
+	if( cl.maxclients <= 1 || Host_IsQuakeCompatible( ))
 		return;
 
 	// check sprites first
@@ -164,7 +163,7 @@ void CL_AddClientResources( void )
 	// then check sounds
 	for( i = 0; i < ARRAYSIZE( cl_player_shell_sounds ); i++ )
 	{
-		Q_snprintf( filepath, sizeof( filepath ), "%s%s", DEFAULT_SOUNDPATH, cl_player_shell_sounds[i] );
+		Q_snprintf( filepath, sizeof( filepath ), DEFAULT_SOUNDPATH "%s", cl_player_shell_sounds[i] );
 
 		if( !FS_FileExists( filepath, false ))
 			CL_AddClientResource( cl_player_shell_sounds[i], t_sound );
@@ -172,7 +171,7 @@ void CL_AddClientResources( void )
 
 	for( i = 0; i < ARRAYSIZE( cl_weapon_shell_sounds ); i++ )
 	{
-		Q_snprintf( filepath, sizeof( filepath ), "%s%s", DEFAULT_SOUNDPATH, cl_weapon_shell_sounds[i] );
+		Q_snprintf( filepath, sizeof( filepath ), DEFAULT_SOUNDPATH "%s", cl_weapon_shell_sounds[i] );
 
 		if( !FS_FileExists( filepath, false ))
 			CL_AddClientResource( cl_weapon_shell_sounds[i], t_sound );
@@ -180,7 +179,7 @@ void CL_AddClientResources( void )
 
 	for( i = 0; i < ARRAYSIZE( cl_explode_sounds ); i++ )
 	{
-		Q_snprintf( filepath, sizeof( filepath ), "%s%s", DEFAULT_SOUNDPATH, cl_explode_sounds[i] );
+		Q_snprintf( filepath, sizeof( filepath ), DEFAULT_SOUNDPATH "%s", cl_explode_sounds[i] );
 
 		if( !FS_FileExists( filepath, false ))
 			CL_AddClientResource( cl_explode_sounds[i], t_sound );
@@ -189,7 +188,7 @@ void CL_AddClientResources( void )
 #if 0	// ric sounds was precached by server-side
 	for( i = 0; i < ARRAYSIZE( cl_ricochet_sounds ); i++ )
 	{
-		Q_snprintf( filepath, sizeof( filepath ), "%s%s", DEFAULT_SOUNDPATH, cl_ricochet_sounds[i] );
+		Q_snprintf( filepath, sizeof( filepath ), DEFAULT_SOUNDPATH "%s", cl_ricochet_sounds[i] );
 
 		if( !FS_FileExists( filepath, false ))
 			CL_AddClientResource( cl_ricochet_sounds[i], t_sound );
@@ -197,125 +196,6 @@ void CL_AddClientResources( void )
 #endif
 }
 
-/*
-===============
-CL_FxBlend
-===============
-*/
-int CL_FxBlend( cl_entity_t *e )
-{
-	int	blend = 0;
-	float	offset, dist;
-	vec3_t	tmp;
-
-	offset = ((int)e->index ) * 363.0f; // Use ent index to de-sync these fx
-
-	switch( e->curstate.renderfx ) 
-	{
-	case kRenderFxPulseSlowWide:
-		blend = e->curstate.renderamt + 0x40 * sin( cl.time * 2 + offset );	
-		break;
-	case kRenderFxPulseFastWide:
-		blend = e->curstate.renderamt + 0x40 * sin( cl.time * 8 + offset );
-		break;
-	case kRenderFxPulseSlow:
-		blend = e->curstate.renderamt + 0x10 * sin( cl.time * 2 + offset );
-		break;
-	case kRenderFxPulseFast:
-		blend = e->curstate.renderamt + 0x10 * sin( cl.time * 8 + offset );
-		break;
-	case kRenderFxFadeSlow:			
-		if( RP_NORMALPASS( ))
-		{
-			if( e->curstate.renderamt > 0 ) 
-				e->curstate.renderamt -= 1;
-			else e->curstate.renderamt = 0;
-		}
-		blend = e->curstate.renderamt;
-		break;
-	case kRenderFxFadeFast:
-		if( RP_NORMALPASS( ))
-		{
-			if( e->curstate.renderamt > 3 ) 
-				e->curstate.renderamt -= 4;
-			else e->curstate.renderamt = 0;
-		}
-		blend = e->curstate.renderamt;
-		break;
-	case kRenderFxSolidSlow:
-		if( RP_NORMALPASS( ))
-		{
-			if( e->curstate.renderamt < 255 ) 
-				e->curstate.renderamt += 1;
-			else e->curstate.renderamt = 255;
-		}
-		blend = e->curstate.renderamt;
-		break;
-	case kRenderFxSolidFast:
-		if( RP_NORMALPASS( ))
-		{
-			if( e->curstate.renderamt < 252 ) 
-				e->curstate.renderamt += 4;
-			else e->curstate.renderamt = 255;
-		}
-		blend = e->curstate.renderamt;
-		break;
-	case kRenderFxStrobeSlow:
-		blend = 20 * sin( cl.time * 4 + offset );
-		if( blend < 0 ) blend = 0;
-		else blend = e->curstate.renderamt;
-		break;
-	case kRenderFxStrobeFast:
-		blend = 20 * sin( cl.time * 16 + offset );
-		if( blend < 0 ) blend = 0;
-		else blend = e->curstate.renderamt;
-		break;
-	case kRenderFxStrobeFaster:
-		blend = 20 * sin( cl.time * 36 + offset );
-		if( blend < 0 ) blend = 0;
-		else blend = e->curstate.renderamt;
-		break;
-	case kRenderFxFlickerSlow:
-		blend = 20 * (sin( cl.time * 2 ) + sin( cl.time * 17 + offset ));
-		if( blend < 0 ) blend = 0;
-		else blend = e->curstate.renderamt;
-		break;
-	case kRenderFxFlickerFast:
-		blend = 20 * (sin( cl.time * 16 ) + sin( cl.time * 23 + offset ));
-		if( blend < 0 ) blend = 0;
-		else blend = e->curstate.renderamt;
-		break;
-	case kRenderFxHologram:
-	case kRenderFxDistort:
-		VectorCopy( e->origin, tmp );
-		VectorSubtract( tmp, RI.vieworg, tmp );
-		dist = DotProduct( tmp, RI.vforward );
-			
-		// turn off distance fade
-		if( e->curstate.renderfx == kRenderFxDistort )
-			dist = 1;
-
-		if( dist <= 0 )
-		{
-			blend = 0;
-		}
-		else 
-		{
-			e->curstate.renderamt = 180;
-			if( dist <= 100 ) blend = e->curstate.renderamt;
-			else blend = (int) ((1.0f - ( dist - 100 ) * ( 1.0f / 400.0f )) * e->curstate.renderamt );
-			blend += COM_RandomLong( -32, 31 );
-		}
-		break;
-	default:
-		blend = e->curstate.renderamt;
-		break;
-	}
-
-	blend = bound( 0, blend, 255 );
-
-	return blend;
-}
 
 /*
 ================
@@ -442,15 +322,15 @@ void CL_TempEntPlaySound( TEMPENTITY *pTemp, float damp )
 		Q_snprintf( soundname, sizeof( soundname ), "debris/wood%i.wav", COM_RandomLong( 1, 4 ));
 		break;
 	case BOUNCE_SHRAP:
-		Q_snprintf( soundname, sizeof( soundname ), "%s", cl_ricochet_sounds[COM_RandomLong( 0, 4 )] );
+		Q_strncpy( soundname, cl_ricochet_sounds[COM_RandomLong( 0, 4 )], sizeof( soundname ) );
 		break;
 	case BOUNCE_SHOTSHELL:
-		Q_snprintf( soundname, sizeof( soundname ), "%s", cl_weapon_shell_sounds[COM_RandomLong( 0, 2 )] );
+		Q_strncpy( soundname, cl_weapon_shell_sounds[COM_RandomLong( 0, 2 )], sizeof( soundname ) );
 		isshellcasing = true; // shell casings have different playback parameters
 		fvol = 0.5f;
 		break;
 	case BOUNCE_SHELL:
-		Q_snprintf( soundname, sizeof( soundname ), "%s", cl_player_shell_sounds[COM_RandomLong( 0, 2 )] );
+		Q_strncpy( soundname, cl_player_shell_sounds[COM_RandomLong( 0, 2 )], sizeof( soundname ) );
 		isshellcasing = true; // shell casings have different playback parameters
 		break;
 	case BOUNCE_CONCRETE:
@@ -481,8 +361,8 @@ void CL_TempEntPlaySound( TEMPENTITY *pTemp, float damp )
 		sound_t	handle;
 
 		if( isshellcasing )
-			fvol *= min ( 1.0f, ((float)zvel) / 350.0f ); 
+			fvol *= Q_min( 1.0f, ((float)zvel) / 350.0f );
-		else fvol *= min ( 1.0f, ((float)zvel) / 450.0f ); 
+		else fvol *= Q_min( 1.0f, ((float)zvel) / 450.0f );
 
 		if( !COM_RandomLong( 0, 3 ) && !isshellcasing )
 			pitch = COM_RandomLong( 95, 105 );
@@ -521,8 +401,7 @@ int CL_TempEntAddEntity( cl_entity_t *pEntity )
 		VectorCopy( pEntity->origin, pEntity->latched.prevorigin );
 
 		// add to list
-		if( CL_AddVisibleEntity( pEntity, ET_TEMPENTITY ))
+		CL_AddVisibleEntity( pEntity, ET_TEMPENTITY );
-			r_stats.c_active_tents_count++;
 
 		return 1;
 	}
@@ -671,7 +550,7 @@ CL_TempEntAlloc
 custom tempentity allocation
 ==============
 */
-TEMPENTITY *CL_TempEntAllocCustom( const vec3_t org, model_t *model, int high, void (*pfn)( TEMPENTITY*, float, float ))
+TEMPENTITY * GAME_EXPORT CL_TempEntAllocCustom( const vec3_t org, model_t *model, int high, void (*pfn)( TEMPENTITY*, float, float ))
 {
 	TEMPENTITY	*pTemp;
 
@@ -708,7 +587,7 @@ R_FizzEffect
 Create a fizz effect
 ==============
 */
-void R_FizzEffect( cl_entity_t *pent, int modelIndex, int density )
+void GAME_EXPORT R_FizzEffect( cl_entity_t *pent, int modelIndex, int density )
 {
 	TEMPENTITY	*pTemp;
 	int		i, width, depth, count;
@@ -771,7 +650,7 @@ R_Bubbles
 Create bubbles
 ==============
 */
-void R_Bubbles( const vec3_t mins, const vec3_t maxs, float height, int modelIndex, int count, float speed )
+void GAME_EXPORT R_Bubbles( const vec3_t mins, const vec3_t maxs, float height, int modelIndex, int count, float speed )
 {
 	TEMPENTITY	*pTemp;
 	float		sine, cosine;
@@ -817,7 +696,7 @@ R_BubbleTrail
 Create bubble trail
 ==============
 */
-void R_BubbleTrail( const vec3_t start, const vec3_t end, float height, int modelIndex, int count, float speed )
+void GAME_EXPORT R_BubbleTrail( const vec3_t start, const vec3_t end, float height, int modelIndex, int count, float speed )
 {
 	TEMPENTITY	*pTemp;
 	float		sine, cosine, zspeed;
@@ -862,7 +741,7 @@ R_AttachTentToPlayer
 Attaches entity to player
 ==============
 */
-void R_AttachTentToPlayer( int client, int modelIndex, float zoffset, float life )
+void GAME_EXPORT R_AttachTentToPlayer( int client, int modelIndex, float zoffset, float life )
 {
 	TEMPENTITY	*pTemp;
 	vec3_t		position;
@@ -918,7 +797,7 @@ R_KillAttachedTents
 Detach entity from player
 ==============
 */
-void R_KillAttachedTents( int client )
+void GAME_EXPORT R_KillAttachedTents( int client )
 {
 	int	i;
 
@@ -949,7 +828,7 @@ R_RicochetSprite
 Create ricochet sprite
 ==============
 */
-void R_RicochetSprite( const vec3_t pos, model_t *pmodel, float duration, float scale )
+void GAME_EXPORT R_RicochetSprite( const vec3_t pos, model_t *pmodel, float duration, float scale )
 {
 	TEMPENTITY	*pTemp;
 
@@ -975,7 +854,7 @@ R_RocketFlare
 Create rocket flare
 ==============
 */
-void R_RocketFlare( const vec3_t pos )
+void GAME_EXPORT R_RocketFlare( const vec3_t pos )
 {
 	TEMPENTITY	*pTemp;
 
@@ -1001,7 +880,7 @@ R_MuzzleFlash
 Do muzzleflash
 ==============
 */
-void R_MuzzleFlash( const vec3_t pos, int type )
+void GAME_EXPORT R_MuzzleFlash( const vec3_t pos, int type )
 {
 	TEMPENTITY	*pTemp;
 	int		index;
@@ -1040,7 +919,7 @@ Create a high priority blood sprite
 and some blood drops. This is high-priority tent
 ==============
 */
-void R_BloodSprite( const vec3_t org, int colorIndex, int modelIndex, int modelIndex2, float size )
+void GAME_EXPORT R_BloodSprite( const vec3_t org, int colorIndex, int modelIndex, int modelIndex2, float size )
 {
 	model_t		*pModel, *pModel2;
 	int		impactindex;
@@ -1126,7 +1005,7 @@ R_BreakModel
 Create a shards
 ==============
 */
-void R_BreakModel( const vec3_t pos, const vec3_t size, const vec3_t dir, float random, float life, int count, int modelIndex, char flags )
+void GAME_EXPORT R_BreakModel( const vec3_t pos, const vec3_t size, const vec3_t dir, float random, float life, int count, int modelIndex, char flags )
 {
 	TEMPENTITY	*pTemp;
 	model_t		*pmodel;
@@ -1158,7 +1037,7 @@ void R_BreakModel( const vec3_t pos, const vec3_t size, const vec3_t dir, float
 			vecSpot[1] = pos[1] + COM_RandomFloat( -0.5f, 0.5f ) * size[1];
 			vecSpot[2] = pos[2] + COM_RandomFloat( -0.5f, 0.5f ) * size[2];
 
-			if( CL_PointContents( vecSpot ) != CONTENTS_SOLID )
+			if( PM_CL_PointContents( vecSpot, NULL ) != CONTENTS_SOLID )
 				break; // valid spot
 		}
 
@@ -1301,7 +1180,7 @@ R_SparkShower
 Create an animated moving sprite
 ===============
 */
-void R_SparkShower( const vec3_t pos )
+void GAME_EXPORT R_SparkShower( const vec3_t pos )
 {
 	TEMPENTITY	*pTemp;
 
@@ -1364,39 +1243,30 @@ R_Sprite_Explode
 apply params for exploding sprite
 ===============
 */
-void R_Sprite_Explode( TEMPENTITY *pTemp, float scale, int flags )
+void GAME_EXPORT R_Sprite_Explode( TEMPENTITY *pTemp, float scale, int flags )
 {
-	if( !pTemp ) return;
+	qboolean noadditive, drawalpha, rotate;
 
-	if( FBitSet( flags, TE_EXPLFLAG_NOADDITIVE ))
+	if( !pTemp )
-	{
+		return;
-		// solid sprite
-		pTemp->entity.curstate.rendermode = kRenderNormal;
-		pTemp->entity.curstate.renderamt = 255; 
-	}
-	else if( FBitSet( flags, TE_EXPLFLAG_DRAWALPHA ))
-	{
-		// alpha sprite (came from hl2)
-		pTemp->entity.curstate.rendermode = kRenderTransAlpha;
-		pTemp->entity.curstate.renderamt = 180;
-	}
-	else
-	{
-		// additive sprite
-		pTemp->entity.curstate.rendermode = kRenderTransAdd;
-		pTemp->entity.curstate.renderamt = 180;
-	}
 
-	if( FBitSet( flags, TE_EXPLFLAG_ROTATE ))
+	noadditive = FBitSet( flags, TE_EXPLFLAG_NOADDITIVE );
-	{
+	drawalpha  = FBitSet( flags, TE_EXPLFLAG_DRAWALPHA );
-		// came from hl2
+	rotate     = FBitSet( flags, TE_EXPLFLAG_ROTATE );
-		pTemp->entity.angles[2] = COM_RandomLong( 0, 360 );
-	}
 
-	pTemp->entity.curstate.renderfx = kRenderFxNone;
-	pTemp->entity.baseline.origin[2] = 8;
-	pTemp->entity.origin[2] += 10;
 	pTemp->entity.curstate.scale = scale;
+	pTemp->entity.baseline.origin[2] = 8.0f;
+	pTemp->entity.origin[2] = pTemp->entity.origin[2] + 10.0f;
+	if( rotate )
+		pTemp->entity.angles[2] = COM_RandomFloat( 0.0, 360.0f );
+
+	pTemp->entity.curstate.rendermode = noadditive ? kRenderNormal :
+		drawalpha ? kRenderTransAlpha : kRenderTransAdd;
+	pTemp->entity.curstate.renderamt  = noadditive ? 0xff : 0xb4;
+	pTemp->entity.curstate.renderfx = 0;
+	pTemp->entity.curstate.rendercolor.r = 0;
+	pTemp->entity.curstate.rendercolor.g = 0;
+	pTemp->entity.curstate.rendercolor.b = 0;
 }
 
 /*
@@ -1406,7 +1276,7 @@ R_Sprite_Smoke
 apply params for smoke sprite
 ===============
 */
-void R_Sprite_Smoke( TEMPENTITY *pTemp, float scale )
+void GAME_EXPORT R_Sprite_Smoke( TEMPENTITY *pTemp, float scale )
 {
 	int	iColor;
 
@@ -1430,7 +1300,7 @@ R_Spray
 Throws a shower of sprites or models
 ===============
 */
-void R_Spray( const vec3_t pos, const vec3_t dir, int modelIndex, int count, int speed, int spread, int rendermode )
+void GAME_EXPORT R_Spray( const vec3_t pos, const vec3_t dir, int modelIndex, int count, int speed, int spread, int rendermode )
 {
 	TEMPENTITY	*pTemp;
 	float		noise;
@@ -1496,7 +1366,7 @@ R_Sprite_Spray
 Spray of alpha sprites
 ===============
 */
-void R_Sprite_Spray( const vec3_t pos, const vec3_t dir, int modelIndex, int count, int speed, int spread )
+void GAME_EXPORT R_Sprite_Spray( const vec3_t pos, const vec3_t dir, int modelIndex, int count, int speed, int spread )
 {
 	R_Spray( pos, dir, modelIndex, count, speed, spread, kRenderGlow );
 }
@@ -1509,7 +1379,7 @@ Line of moving glow sprites with gravity,
 fadeout, and collisions
 ===============
 */
-void R_Sprite_Trail( int type, vec3_t start, vec3_t end, int modelIndex, int count, float life, float size, float amp, int renderamt, float speed )
+void GAME_EXPORT R_Sprite_Trail( int type, vec3_t start, vec3_t end, int modelIndex, int count, float life, float size, float amp, int renderamt, float speed )
 {
 	TEMPENTITY	*pTemp;
 	vec3_t		delta, dir;
@@ -1561,7 +1431,7 @@ R_FunnelSprite
 Create a funnel effect with custom sprite
 ===============
 */
-void R_FunnelSprite( const vec3_t org, int modelIndex, int reverse )
+void GAME_EXPORT R_FunnelSprite( const vec3_t org, int modelIndex, int reverse )
 {
 	TEMPENTITY	*pTemp;
 	vec3_t		dir, dest;
@@ -1603,7 +1473,6 @@ void R_FunnelSprite( const vec3_t org, int modelIndex, int reverse )
 			pTemp->entity.baseline.angles[2] = COM_RandomFloat( -100.0f, 100.0f );
 			pTemp->entity.curstate.framerate = COM_RandomFloat( 0.1f, 0.4f );
 			pTemp->flags = FTENT_ROTATE|FTENT_FADEOUT;
-			pTemp->entity.curstate.framerate = 10;
 
 			vel = dest[2] / 8.0f;
 			if( vel < 64.0f ) vel = 64.0f;
@@ -1623,7 +1492,7 @@ R_SparkEffect
 Create a streaks + richochet sprite
 ===============
 */
-void R_SparkEffect( const vec3_t pos, int count, int velocityMin, int velocityMax )
+void GAME_EXPORT R_SparkEffect( const vec3_t pos, int count, int velocityMin, int velocityMax )
 {
 	R_RicochetSprite( pos, cl_sprite_ricochet, 0.1f, COM_RandomFloat( 0.5f, 1.0f ));
 	R_SparkStreaks( pos, count, velocityMin, velocityMax );
@@ -1636,17 +1505,18 @@ R_RicochetSound
 Make a random ricochet sound
 ==============
 */
-void R_RicochetSound( const vec3_t pos )
+static void R_RicochetSound_( const vec3_t pos, int sound )
 {
-	int	iPitch = COM_RandomLong( 90, 105 );
-	float	fvol = COM_RandomFloat( 0.7f, 0.9f );
-	char	soundpath[32];
 	sound_t	handle;
 
-	Q_snprintf( soundpath, sizeof( soundpath ), "%s", cl_ricochet_sounds[COM_RandomLong( 0, 4 )] );
+	handle = S_RegisterSound( cl_ricochet_sounds[sound] );
-	handle = S_RegisterSound( soundpath );
 
-	S_StartSound( pos, 0, CHAN_AUTO, handle, fvol, ATTN_NORM, iPitch, 0 );
+	S_StartSound( pos, 0, CHAN_AUTO, handle, VOL_NORM, 1.0, 100, 0 );
+}
+
+void GAME_EXPORT R_RicochetSound( const vec3_t pos )
+{
+	R_RicochetSound_( pos, COM_RandomLong( 0, 4 ));
 }
 
 /*
@@ -1656,7 +1526,7 @@ R_Projectile
 Create an projectile entity
 ==============
 */
-void R_Projectile( const vec3_t origin, const vec3_t velocity, int modelIndex, int life, int owner, void (*hitcallback)( TEMPENTITY*, pmtrace_t* ))
+void GAME_EXPORT R_Projectile( const vec3_t origin, const vec3_t velocity, int modelIndex, int life, int owner, void (*hitcallback)( TEMPENTITY*, pmtrace_t* ))
 {
 	TEMPENTITY	*pTemp;
 	model_t		*pmodel;
@@ -1705,7 +1575,7 @@ R_TempSphereModel
 Spherical shower of models, picks from set
 ==============
 */
-void R_TempSphereModel( const vec3_t pos, float speed, float life, int count, int modelIndex )
+void GAME_EXPORT R_TempSphereModel( const vec3_t pos, float speed, float life, int count, int modelIndex )
 {
 	TEMPENTITY	*pTemp;
 	int		i;
@@ -1753,7 +1623,7 @@ R_Explosion
 Create an explosion (scale is magnitude)
 ==============
 */
-void R_Explosion( vec3_t pos, int model, float scale, float framerate, int flags )
+void GAME_EXPORT R_Explosion( vec3_t pos, int model, float scale, float framerate, int flags )
 {
 	sound_t	hSound;
 
@@ -1777,7 +1647,7 @@ void R_Explosion( vec3_t pos, int model, float scale, float framerate, int flags
 			dl->color.g = 250;
 			dl->color.b = 150;
 			dl->die = cl.time + 0.01f;
-			dl->decay = 80;
+			dl->decay = 800;
 
 			// red glow
 			dl = CL_AllocDlight( 0 );
@@ -1793,7 +1663,7 @@ void R_Explosion( vec3_t pos, int model, float scale, float framerate, int flags
 
 	if( !FBitSet( flags, TE_EXPLFLAG_NOSOUND ))
 	{
-		hSound = S_RegisterSound( va( "%s", cl_explode_sounds[COM_RandomLong( 0, 2 )] ));
+		hSound = S_RegisterSound( cl_explode_sounds[COM_RandomLong( 0, 2 )] );
 		S_StartSound( pos, 0, CHAN_STATIC, hSound, VOL_NORM, 0.3f, PITCH_NORM, 0 );
 	}
 }
@@ -1805,7 +1675,7 @@ R_PlayerSprites
 Create a particle smoke around player
 ==============
 */
-void R_PlayerSprites( int client, int modelIndex, int count, int size )
+void GAME_EXPORT R_PlayerSprites( int client, int modelIndex, int count, int size )
 {
 	TEMPENTITY	*pTemp;
 	cl_entity_t	*pEnt;
@@ -1870,7 +1740,7 @@ R_FireField
 Makes a field of fire
 ==============
 */
-void R_FireField( float *org, int radius, int modelIndex, int count, int flags, float life )
+void GAME_EXPORT R_FireField( float *org, int radius, int modelIndex, int count, int flags, float life )
 {
 	TEMPENTITY	*pTemp;
 	model_t		*pmodel;
@@ -1945,7 +1815,7 @@ R_MultiGunshot
 Client version of shotgun shot
 ==============
 */
-void R_MultiGunshot( const vec3_t org, const vec3_t dir, const vec3_t noise, int count, int decalCount, int *decalIndices )
+void GAME_EXPORT R_MultiGunshot( const vec3_t org, const vec3_t dir, const vec3_t noise, int count, int decalCount, int *decalIndices )
 {
 	pmtrace_t	trace;
 	vec3_t	right, up;
@@ -2001,7 +1871,7 @@ R_Sprite_WallPuff
 Create a wallpuff
 ==============
 */
-void R_Sprite_WallPuff( TEMPENTITY *pTemp, float scale )
+void GAME_EXPORT R_Sprite_WallPuff( TEMPENTITY *pTemp, float scale )
 {
 	if( !pTemp ) return;
 
@@ -2013,6 +1883,8 @@ void R_Sprite_WallPuff( TEMPENTITY *pTemp, float scale )
 	pTemp->die = cl.time + 0.01f;
 }
 
+
+
 /*
 ==============
 CL_ParseTempEntity
@@ -2023,8 +1895,8 @@ handle temp-entity messages
 void CL_ParseTempEntity( sizebuf_t *msg )
 {
 	sizebuf_t		buf;
-	byte		pbuf[256];
+	byte		pbuf[2048];
-	int		iSize = MSG_ReadWord( msg );
+	int		iSize;
 	int		type, color, count, flags;
 	int		decalIndex, modelIndex, entityIndex;
 	float		scale, life, frameRate, vel, random;
@@ -2034,9 +1906,18 @@ void CL_ParseTempEntity( sizebuf_t *msg )
 	TEMPENTITY	*pTemp;
 	cl_entity_t	*pEnt;
 	dlight_t		*dl;
+	sound_t	hSound;
+
+	if( cls.legacymode )
+		iSize = MSG_ReadByte( msg );
+	else iSize = MSG_ReadWord( msg );
 
 	decalIndex = modelIndex = entityIndex = 0;
 
+	// this will probably be fatal anyway
+	if( iSize > sizeof( pbuf ))
+		Con_Printf( S_ERROR "%s: Temp buffer overflow!\n", __FUNCTION__ );
+
 	// parse user message into buffer
 	MSG_ReadBytes( msg, pbuf, iSize );
 
@@ -2084,6 +1965,9 @@ void CL_ParseTempEntity( sizebuf_t *msg )
 		pos[1] = MSG_ReadCoord( &buf );
 		pos[2] = MSG_ReadCoord( &buf );
 		R_BlobExplosion( pos );
+
+		hSound = S_RegisterSound( cl_explode_sounds[0] );
+		S_StartSound( pos, -1, CHAN_AUTO, hSound, VOL_NORM, 1.0f, PITCH_NORM, 0 );
 		break;
 	case TE_SMOKE:
 		pos[0] = MSG_ReadCoord( &buf );
@@ -2129,15 +2013,46 @@ void CL_ParseTempEntity( sizebuf_t *msg )
 		color = MSG_ReadByte( &buf );
 		count = MSG_ReadByte( &buf );
 		R_ParticleExplosion2( pos, color, count );
+
+		dl = CL_AllocDlight( 0 );
+		VectorCopy( pos, dl->origin );
+		dl->radius = 350;
+		dl->die = cl.time + 0.5;
+		dl->decay = 300;
+
+		hSound = S_RegisterSound( cl_explode_sounds[0] );
+		S_StartSound( pos, -1, CHAN_AUTO, hSound, VOL_NORM, 0.6f, PITCH_NORM, 0 );
 		break;
 	case TE_BSPDECAL:
+	case TE_DECAL:
+	case TE_WORLDDECAL:
+	case TE_WORLDDECALHIGH:
+	case TE_DECALHIGH:
 		pos[0] = MSG_ReadCoord( &buf );
 		pos[1] = MSG_ReadCoord( &buf );
 		pos[2] = MSG_ReadCoord( &buf );
+		if( type == TE_BSPDECAL )
+		{
 			decalIndex = MSG_ReadShort( &buf );
 			entityIndex = MSG_ReadShort( &buf );
-		if( entityIndex ) modelIndex = MSG_ReadShort( &buf );
+			if( entityIndex )
-		CL_DecalShoot( CL_DecalIndex( decalIndex ), entityIndex, modelIndex, pos, FDECAL_PERMANENT );
+				modelIndex = MSG_ReadShort( &buf );
+			else modelIndex = 0;
+		}
+		else
+		{
+			decalIndex = MSG_ReadByte( &buf );
+			if( type == TE_DECALHIGH || type == TE_WORLDDECALHIGH )
+				decalIndex += 256;
+
+			if( type == TE_DECALHIGH || type == TE_DECAL )
+				entityIndex = MSG_ReadShort( &buf );
+			else entityIndex = 0;
+
+			pEnt = CL_GetEntityByIndex( entityIndex );
+			modelIndex = pEnt->curstate.modelindex;
+		}
+		CL_DecalShoot( CL_DecalIndex( decalIndex ), entityIndex, modelIndex, pos, type == TE_BSPDECAL ? FDECAL_PERMANENT : 0 );
 		break;
 	case TE_IMPLOSION:
 		pos[0] = MSG_ReadCoord( &buf );
@@ -2157,10 +2072,12 @@ void CL_ParseTempEntity( sizebuf_t *msg )
 		pos2[2] = MSG_ReadCoord( &buf );
 		modelIndex = MSG_ReadShort( &buf );
 		count = MSG_ReadByte( &buf );
-		life = (float)(MSG_ReadByte( &buf ) * 0.1f);
+		life = (float)MSG_ReadByte( &buf ) * 0.1f;
-		scale = (float)(MSG_ReadByte( &buf ) * 0.1f);
+		scale = (float)MSG_ReadByte( &buf );
-		vel = (float)MSG_ReadByte( &buf );
+		if( !scale ) scale = 1.0f;
-		random = (float)MSG_ReadByte( &buf );
+		else scale *= 0.1f;
+		vel = (float)MSG_ReadByte( &buf ) * 10;
+		random = (float)MSG_ReadByte( &buf ) * 10;
 		R_Sprite_Trail( type, pos, pos2, modelIndex, count, life, scale, random, 255, vel );
 		break;
 	case TE_SPRITE:
@@ -2168,36 +2085,23 @@ void CL_ParseTempEntity( sizebuf_t *msg )
 		pos[1] = MSG_ReadCoord( &buf );
 		pos[2] = MSG_ReadCoord( &buf );
 		modelIndex = MSG_ReadShort( &buf );
-		scale = (float)(MSG_ReadByte( &buf ) * 0.1f);
+		scale = (float)MSG_ReadByte( &buf ) * 0.1f;
-		brightness = (float)MSG_ReadByte( &buf );
+		brightness = (float)MSG_ReadByte( &buf ) / 255.0f;
 
-		if(( pTemp = R_DefaultSprite( pos, modelIndex, 0 )) != NULL )
+		R_TempSprite( pos, vec3_origin, scale, modelIndex,
-		{
+			kRenderTransAdd, kRenderFxNone, brightness, 0.0, FTENT_SPRANIMATE );
-			pTemp->entity.curstate.scale = scale;
-			pTemp->entity.baseline.renderamt = brightness;
-			pTemp->entity.curstate.renderamt = brightness;
-			pTemp->entity.curstate.rendermode = kRenderTransAdd;
-		}
 		break;
 	case TE_GLOWSPRITE:
 		pos[0] = MSG_ReadCoord( &buf );
 		pos[1] = MSG_ReadCoord( &buf );
 		pos[2] = MSG_ReadCoord( &buf );
 		modelIndex = MSG_ReadShort( &buf );
-		life = (float)(MSG_ReadByte( &buf ) * 0.1f);
+		life = (float)MSG_ReadByte( &buf ) * 0.1f;
-		scale = (float)(MSG_ReadByte( &buf ) * 0.1f);
+		scale = (float)MSG_ReadByte( &buf ) * 0.1f;
-		brightness = (float)MSG_ReadByte( &buf );
+		brightness = (float)MSG_ReadByte( &buf ) / 255.0f;
 
-		if(( pTemp = R_DefaultSprite( pos, modelIndex, 0 )) != NULL )
+		R_TempSprite( pos, vec3_origin, scale, modelIndex,
-		{
+			kRenderGlow, kRenderFxNoDissipation, brightness, life, FTENT_FADEOUT );
-			pTemp->entity.curstate.scale = scale;
-			pTemp->entity.curstate.rendermode = kRenderGlow;
-			pTemp->entity.curstate.renderfx = kRenderFxNoDissipation;
-			pTemp->entity.baseline.renderamt = brightness;
-			pTemp->entity.curstate.renderamt = brightness;
-			pTemp->flags = FTENT_FADEOUT;
-			pTemp->die = cl.time + life;
-		}
 		break;
 	case TE_STREAK_SPLASH:
 		pos[0] = MSG_ReadCoord( &buf );
@@ -2287,23 +2191,6 @@ void CL_ParseTempEntity( sizebuf_t *msg )
 		pos2[2] = MSG_ReadCoord( &buf );
 		R_ShowLine( pos, pos2 );
 		break;
-	case TE_DECAL:
-	case TE_DECALHIGH:
-	case TE_WORLDDECAL:
-	case TE_WORLDDECALHIGH:
-		pos[0] = MSG_ReadCoord( &buf );
-		pos[1] = MSG_ReadCoord( &buf );
-		pos[2] = MSG_ReadCoord( &buf );
-		decalIndex = MSG_ReadByte( &buf );
-		if( type == TE_DECAL || type == TE_DECALHIGH )
-			entityIndex = MSG_ReadShort( &buf );
-		else entityIndex = 0;
-		if( type == TE_DECALHIGH || type == TE_WORLDDECALHIGH )
-			decalIndex += 256;
-		pEnt = CL_GetEntityByIndex( entityIndex );
-		if( pEnt ) modelIndex = pEnt->curstate.modelindex;
-		CL_DecalShoot( CL_DecalIndex( decalIndex ), entityIndex, modelIndex, pos, 0 );
-		break;
 	case TE_FIZZ:
 		entityIndex = MSG_ReadShort( &buf );
 		modelIndex = MSG_ReadShort( &buf );
@@ -2359,10 +2246,11 @@ void CL_ParseTempEntity( sizebuf_t *msg )
 		pos[2] = MSG_ReadCoord( &buf );
 		entityIndex = MSG_ReadShort( &buf );
 		decalIndex = MSG_ReadByte( &buf );
-		pEnt = CL_GetEntityByIndex( entityIndex );
 		CL_DecalShoot( CL_DecalIndex( decalIndex ), entityIndex, 0, pos, 0 );
 		R_BulletImpactParticles( pos );
-		R_RicochetSound( pos );
+		flags = COM_RandomLong( 0, 0x7fff );
+		if( flags < 0x3fff )
+			R_RicochetSound_( pos, flags % 5 );
 		break;
 	case TE_SPRAY:
 	case TE_SPRITE_SPRAY:
@@ -2508,7 +2396,7 @@ void CL_ParseTempEntity( sizebuf_t *msg )
 
 	// throw warning
 	if( MSG_CheckOverflow( &buf ))
-		Con_DPrintf( S_WARN "ParseTempEntity: overflow TE message\n" );
+		Con_DPrintf( S_WARN "ParseTempEntity: overflow TE message %i\n", type );
 }
 
 
@@ -2717,6 +2605,18 @@ void CL_DecayLights( void )
 	}
 }
 
+dlight_t *CL_GetDynamicLight( int number )
+{
+	Assert( number >= 0 && number < MAX_DLIGHTS );
+	return &cl_dlights[number];
+}
+
+dlight_t *CL_GetEntityLight( int number )
+{
+	Assert( number >= 0 && number < MAX_ELIGHTS );
+	return &cl_elights[number];
+}
+
 /*
 ================
 CL_UpdateFlashlight
@@ -2729,7 +2629,7 @@ void CL_UpdateFlashlight( cl_entity_t *ent )
 	vec3_t		forward, view_ofs;
 	vec3_t		vecSrc, vecEnd;
 	float		falloff;
-	pmtrace_t		*trace;
+	pmtrace_t		trace;
 	cl_entity_t	*hit;
 	dlight_t		*dl;
 
@@ -2760,28 +2660,26 @@ void CL_UpdateFlashlight( cl_entity_t *ent )
 	VectorAdd( ent->origin, view_ofs, vecSrc );
 	VectorMA( vecSrc, FLASHLIGHT_DISTANCE, forward, vecEnd );
 
-	trace = CL_VisTraceLine( vecSrc, vecEnd, PM_STUDIO_BOX );
+	trace = CL_TraceLine( vecSrc, vecEnd, PM_STUDIO_BOX );
 
 	// update flashlight endpos
 	dl = CL_AllocDlight( ent->index );
 #if 1
-	hit = CL_GetEntityByIndex( clgame.pmove->visents[trace->ent].info );
+	hit = CL_GetEntityByIndex( clgame.pmove->visents[trace.ent].info );
 	if( hit && hit->model && ( hit->model->type == mod_alias || hit->model->type == mod_studio ))
 		VectorCopy( hit->origin, dl->origin );
-	else VectorCopy( trace->endpos, dl->origin );
+	else VectorCopy( trace.endpos, dl->origin );
 #else
 	VectorCopy( trace->endpos, dl->origin );
 #endif
 	// compute falloff
-	falloff = trace->fraction * FLASHLIGHT_DISTANCE;
+	falloff = trace.fraction * FLASHLIGHT_DISTANCE;
 	if( falloff < 500.0f ) falloff = 1.0f;
 	else falloff = 500.0f / falloff;
 	falloff *= falloff;
 
 	// apply brigthness to dlight
-	dl->color.r = bound( 0, falloff * 255, 255 );
+	dl->color.r = dl->color.g = dl->color.b = bound( 0, falloff * 255, 255 );
-	dl->color.g = bound( 0, falloff * 255, 255 );
-	dl->color.b = bound( 0, falloff * 255, 255 );
 	dl->die = cl.time + 0.01f; // die on next frame
 	dl->radius = 80;
 }
@@ -2796,12 +2694,12 @@ apply various effects to entity origin or attachment
 void CL_AddEntityEffects( cl_entity_t *ent )
 {
 	// yellow flies effect 'monster stuck in the wall'
-	if( FBitSet( ent->curstate.effects, EF_BRIGHTFIELD ))
+	if( FBitSet( ent->curstate.effects, EF_BRIGHTFIELD ) && !RP_LOCALCLIENT( ent ))
 		R_EntityParticles( ent );
 
 	if( FBitSet( ent->curstate.effects, EF_DIMLIGHT ))
 	{
-		if( ent->player && !CL_IsQuakeCompatible( ))
+		if( ent->player && !Host_IsQuakeCompatible( ))
 		{
 			CL_UpdateFlashlight( ent );
 		}
@@ -2943,10 +2841,10 @@ void CL_TestLights( void )
 	float	f, r;
 	dlight_t	*dl;
 
-	if( !CVAR_TO_BOOL( cl_testlights ))
+	if( !cl_testlights.value )
 		return;
 
-	numLights = bound( 1, cl_testlights->value, MAX_DLIGHTS );
+	numLights = bound( 1, cl_testlights.value, MAX_DLIGHTS );
 	AngleVectors( cl.viewangles, forward, right, NULL );
 
 	for( i = 0; i < numLights; i++ )
@@ -2974,18 +2872,6 @@ DECAL MANAGEMENT
 
 ==============================================================
 */
-/*
-===============
-CL_DecalShoot
-
-normal temporary decal
-===============
-*/
-void CL_DecalShoot( int textureIndex, int entityIndex, int modelIndex, float *pos, int flags )
-{
-	R_DecalShoot( textureIndex, entityIndex, modelIndex, pos, flags, 1.0f );
-}
-
 /*
 ===============
 CL_FireCustomDecal
@@ -2993,9 +2879,21 @@ CL_FireCustomDecal
 custom temporary decal
 ===============
 */
-void CL_FireCustomDecal( int textureIndex, int entityIndex, int modelIndex, float *pos, int flags, float scale )
+void GAME_EXPORT CL_FireCustomDecal( int textureIndex, int entityIndex, int modelIndex, float *pos, int flags, float scale )
 {
-	R_DecalShoot( textureIndex, entityIndex, modelIndex, pos, flags, scale );
+	ref.dllFuncs.R_DecalShoot( textureIndex, entityIndex, modelIndex, pos, flags, scale );
+}
+
+/*
+===============
+CL_DecalShoot
+
+normal temporary decal
+===============
+*/
+void GAME_EXPORT CL_DecalShoot( int textureIndex, int entityIndex, int modelIndex, float *pos, int flags )
+{
+	CL_FireCustomDecal( textureIndex, entityIndex, modelIndex, pos, flags, 1.0f );
 }
 
 /*
@@ -3017,16 +2915,24 @@ void CL_PlayerDecal( int playernum, int customIndex, int entityIndex, float *pos
 	{
 		if( FBitSet( pCust->resource.ucFlags, RES_CUSTOM ) && pCust->resource.type == t_decal && pCust->bTranslated )
 		{
-			if( !pCust->nUserData1 && pCust->pInfo != NULL )
+			if( !pCust->nUserData1 )
 			{
-				const char *decalname = va( "player%dlogo%d", playernum, customIndex );
+				int sprayTextureIndex;
+				char decalname[MAX_VA_STRING];
+
+				Q_snprintf( decalname, sizeof( decalname ), "player%dlogo%d", playernum, customIndex );
+				sprayTextureIndex = ref.dllFuncs.GL_FindTexture( decalname );
+				if( sprayTextureIndex != 0 )
+				{
+					ref.dllFuncs.GL_FreeTexture( sprayTextureIndex );
+				}
 				pCust->nUserData1 = GL_LoadTextureInternal( decalname, pCust->pInfo, TF_DECAL );
 			}
 			textureIndex = pCust->nUserData1;
 		}
 	}
 
-	R_DecalShoot( textureIndex, entityIndex, 0, pos, FDECAL_CUSTOM, 1.0f );
+	CL_DecalShoot( textureIndex, entityIndex, 0, pos, FDECAL_CUSTOM );
 }
 
 /*
@@ -3036,7 +2942,7 @@ CL_DecalIndexFromName
 get decal global index from decalname
 ===============
 */
-int CL_DecalIndexFromName( const char *name )
+int GAME_EXPORT CL_DecalIndexFromName( const char *name )
 {
 	int	i;
 
@@ -3059,14 +2965,14 @@ CL_DecalIndex
 get texture index from decal global index
 ===============
 */
-int CL_DecalIndex( int id )
+int GAME_EXPORT CL_DecalIndex( int id )
 {
 	id = bound( 0, id, MAX_DECALS - 1 );
 
 	if( cl.decal_index[id] == 0 )
 	{
 		Image_SetForceFlags( IL_LOAD_DECAL );
-		cl.decal_index[id] = GL_LoadTexture( host.draw_decals[id], NULL, 0, TF_DECAL );
+		cl.decal_index[id] = ref.dllFuncs.GL_LoadTexture( host.draw_decals[id], NULL, 0, TF_DECAL );
 		Image_ClearForceFlags();
 	}
 
@@ -3080,10 +2986,10 @@ CL_DecalRemoveAll
 remove all decals with specified texture
 ===============
 */
-void CL_DecalRemoveAll( int textureIndex )
+void GAME_EXPORT CL_DecalRemoveAll( int textureIndex )
 {
 	int id = bound( 0, textureIndex, MAX_DECALS - 1 );
-	R_DecalRemoveAll( cl.decal_index[id] );
+	ref.dllFuncs.R_DecalRemoveAll( cl.decal_index[id] );
 }
 
 /*
@@ -3113,6 +3019,29 @@ void CL_ClearEfrags( void )
 	clgame.free_efrags[i].entnext = NULL;
 }
 
+/*
+=======================
+R_ClearStaticEntities
+
+e.g. by demo request
+=======================
+*/
+void CL_ClearStaticEntities( void )
+{
+	int	i;
+
+	if( host.type == HOST_DEDICATED )
+		return;
+
+	// clear out efrags in case the level hasn't been reloaded
+	for( i = 0; i < cl.worldmodel->numleafs; i++ )
+		cl.worldmodel->leafs[i+1].efrags = NULL;
+
+	clgame.numStatics = 0;
+
+	CL_ClearEfrags ();
+}
+
 /*
 ==============
 CL_ClearEffects
@@ -3127,3 +3056,4 @@ void CL_ClearEffects( void )
 	CL_ClearParticles ();
 	CL_ClearLightStyles ();
 }
+

engine/client/cl_tent.h

@@ -16,6 +16,8 @@ GNU General Public License for more details.
 #ifndef CL_TENT_H
 #define CL_TENT_H
 
+#include "triangleapi.h"
+
 // EfxAPI
 struct particle_s *R_AllocParticle( void (*callback)( struct particle_s*, float ));
 void R_Explosion( vec3_t pos, int model, float scale, float framerate, int flags );
@@ -87,6 +89,9 @@ void CL_DecalRemoveAll( int textureIndex );
 int CL_DecalIndexFromName( const char *name );
 int CL_DecalIndex( int id );
 
+// RefAPI
+struct particle_s *CL_AllocParticleFast( void );
+
 // Beams
 struct beam_s *R_BeamLightning( vec3_t start, vec3_t end, int modelIndex, float life, float width, float amplitude, float brightness, float speed );
 struct beam_s *R_BeamEnts( int startEnt, int endEnt, int modelIndex, float life, float width, float amplitude, float brightness, float speed, int startFrame, float framerate, float r, float g, float b );
@@ -99,20 +104,16 @@ void R_BeamKill( int deadEntity );
 
 
 // TriAPI
-void TriBegin( int mode );
+void TriRenderMode( int mode );
-void TriTexCoord2f( float u, float v );
-void TriVertex3fv( const float *v );
-void TriVertex3f( float x, float y, float z );
-int TriBoxInPVS( float *mins, float *maxs );
 void TriColor4f( float r, float g, float b, float a );
-int TriSpriteTexture( model_t *pSpriteModel, int frame );
-void TriColor4fRendermode( float r, float g, float b, float a, int rendermode );
-int TriWorldToScreen( float *world, float *screen );
 void TriColor4ub( byte r, byte g, byte b, byte a );
 void TriBrightness( float brightness );
-void TriRenderMode( int mode );
+void TriCullFace( TRICULLSTYLE mode );
-void TriCullFace( int mode );
+int TriWorldToScreen( const float *world, float *screen );
-void TriEnd( void );
+int TriBoxInPVS( float *mins, float *maxs );
+void TriLightAtPoint( float *pos, float *value );
+void TriColor4fRendermode( float r, float g, float b, float a, int rendermode );
+int TriSpriteTexture( model_t *pSpriteModel, int frame );
 
 extern model_t	*cl_sprite_dot;
 extern model_t	*cl_sprite_shell;

engine/client/cl_video.c

@@ -15,7 +15,6 @@ GNU General Public License for more details.
 
 #include "common.h"
 #include "client.h"
-#include "gl_local.h"
 
 /*
 =================================================================
@@ -25,7 +24,7 @@ AVI PLAYING
 =================================================================
 */
 
-static long		xres, yres;
+static int		xres, yres;
 static float		video_duration;
 static float		cin_time;
 static int		cin_frame;
@@ -85,7 +84,8 @@ void SCR_CreateStartupVids( void )
 void SCR_CheckStartupVids( void )
 {
 	int	c = 0;
-	char	*afile, *pfile;
+	byte *afile;
+	char *pfile;
 	string	token;
 
 	if( Sys_CheckParm( "-nointro" ) || host_developer.value || cls.demonum != -1 || GameState->nextstate != STATE_RUNFRAME )
@@ -102,9 +102,9 @@ void SCR_CheckStartupVids( void )
 	afile = FS_LoadFile( DEFAULT_VIDEOLIST_PATH, NULL, false );
 	if( !afile ) return; // something bad happens
 
-	pfile = afile;
+	pfile = (char *)afile;
 
-	while(( pfile = COM_ParseFile( pfile, token )) != NULL )
+	while(( pfile = COM_ParseFile( pfile, token, sizeof( token ))) != NULL )
 	{
 		Q_strncpy( cls.movies[c], token, sizeof( cls.movies[0] ));
 
@@ -180,7 +180,7 @@ qboolean SCR_DrawCinematic( void )
 	qboolean		redraw = false;
 	byte		*frame = NULL;
 
-	if( !glw_state.initialized || cin_time <= 0.0f )
+	if( !ref.initialized || cin_time <= 0.0f )
 		return false;
 
 	if( cin_frame != last_frame )
@@ -190,7 +190,7 @@ qboolean SCR_DrawCinematic( void )
 		redraw = true;
 	}
 
-	R_DrawStretchRaw( 0, 0, glState.width, glState.height, xres, yres, frame, redraw );
+	ref.dllFuncs.R_DrawStretchRaw( 0, 0, refState.width, refState.height, xres, yres, frame, redraw );
 
 	return true;
 }
@@ -202,14 +202,13 @@ SCR_PlayCinematic
 */
 qboolean SCR_PlayCinematic( const char *arg )
 {
-	string		path;
 	const char	*fullpath;
 
 	fullpath = FS_GetDiskPath( arg, false );
 
 	if( FS_FileExists( arg, false ) && !fullpath )
 	{
-		Con_Printf( S_ERROR "Couldn't load %s from packfile. Please extract it\n", path );
+		Con_Printf( S_ERROR "Couldn't load %s from packfile. Please extract it\n", arg );
 		return false;
 	}
 
@@ -242,7 +241,7 @@ qboolean SCR_PlayCinematic( const char *arg )
 	return true;
 }
 
-long SCR_GetAudioChunk( char *rawdata, long length )
+int SCR_GetAudioChunk( char *rawdata, int length )
 {
 	int	r;
 

engine/client/cl_view.c

@@ -17,9 +17,10 @@ GNU General Public License for more details.
 #include "client.h"
 #include "const.h"
 #include "entity_types.h"
-#include "gl_local.h"
 #include "vgui_draw.h"
 #include "sound.h"
+#include "input.h" // touch
+#include "platform/platform.h" // GL_UpdateSwapInterval
 
 /*
 ===============
@@ -34,9 +35,11 @@ void V_CalcViewRect( void )
 	int	sb_lines;
 	float	size;
 
+	if( FBitSet( host.features, ENGINE_QUAKE_COMPATIBLE ))
+	{
 		// intermission is always full screen
 		if( cl.intermission ) size = 120.0f;
-	else size = scr_viewsize->value;
+		else size = scr_viewsize.value;
 
 		if( size >= 120.0f )
 			sb_lines = 0;		// no status bar at all
@@ -44,12 +47,12 @@ void V_CalcViewRect( void )
 			sb_lines = 24;		// no inventory
 		else sb_lines = 48;
 
-	if( scr_viewsize->value >= 100.0 )
+		if( scr_viewsize.value >= 100.0f )
 		{
 			full = true;
 			size = 100.0f;
 		}
-	else size = scr_viewsize->value;
+		else size = scr_viewsize.value;
 
 		if( cl.intermission )
 		{
@@ -57,19 +60,26 @@ void V_CalcViewRect( void )
 			sb_lines = 0;
 			full = true;
 		}
-	size /= 100.0;
+		size /= 100.0f;
+	}
+	else
+	{
+		full = true;
+		sb_lines = 0;
+		size = 1.0f;
+	}
 
-	clgame.viewport[2] = glState.width * size;
+	clgame.viewport[2] = refState.width * size;
-	clgame.viewport[3] = glState.height * size;
+	clgame.viewport[3] = refState.height * size;
 
-	if( clgame.viewport[3] > glState.height - sb_lines )
+	if( clgame.viewport[3] > refState.height - sb_lines )
-		clgame.viewport[3] = glState.height - sb_lines;
+		clgame.viewport[3] = refState.height - sb_lines;
-	if( clgame.viewport[3] > glState.height )
+	if( clgame.viewport[3] > refState.height )
-		clgame.viewport[3] = glState.height;
+		clgame.viewport[3] = refState.height;
 
-	clgame.viewport[0] = ( glState.width - clgame.viewport[2] ) / 2;
+	clgame.viewport[0] = ( refState.width - clgame.viewport[2] ) / 2;
 	if( full ) clgame.viewport[1] = 0;
-	else clgame.viewport[1] = ( glState.height - sb_lines - clgame.viewport[3] ) / 2;
+	else clgame.viewport[1] = ( refState.height - sb_lines - clgame.viewport[3] ) / 2;
 
 }
 
@@ -113,8 +123,8 @@ void V_SetRefParams( ref_params_t *fd )
 	memset( fd, 0, sizeof( ref_params_t ));
 
 	// probably this is not needs
-	VectorCopy( RI.vieworg, fd->vieworg );
+	VectorCopy( refState.vieworg, fd->vieworg );
-	VectorCopy( RI.viewangles, fd->viewangles );
+	VectorCopy( refState.viewangles, fd->viewangles );
 
 	fd->frametime = host.frametime;
 	fd->time = cl.time;
@@ -134,7 +144,7 @@ void V_SetRefParams( ref_params_t *fd )
 	VectorCopy( cl.viewangles, fd->cl_viewangles );
 	fd->health = cl.local.health;
 	VectorCopy( cl.crosshairangle, fd->crosshairangle );
-	fd->viewsize = scr_viewsize->value;
+	fd->viewsize = scr_viewsize.value;
 
 	VectorCopy( cl.punchangle, fd->punchangle );
 	fd->maxclients = cl.maxclients;
@@ -183,7 +193,7 @@ void V_RefApplyOverview( ref_viewpass_t *rvp )
 		return;
 
 	// NOTE: Xash3D may use 16:9 or 16:10 aspects
-	aspect = (float)glState.width / (float)glState.height;
+	aspect = (float)refState.width / (float)refState.height;
 
 	size_x = fabs( 8192.0f / ov->flZoom );
 	size_y = fabs( 8192.0f / (ov->flZoom * aspect ));
@@ -216,7 +226,54 @@ void V_RefApplyOverview( ref_viewpass_t *rvp )
 
 	SetBits( rvp->flags, RF_DRAW_OVERVIEW );
 
-	Mod_SetOrthoBounds( mins, maxs );
+	ref.dllFuncs.GL_OrthoBounds( mins, maxs );
+}
+
+/*
+====================
+V_CalcFov
+====================
+*/
+static float V_CalcFov( float *fov_x, float width, float height )
+{
+	float	x, half_fov_y;
+
+	if( *fov_x < 1.0f || *fov_x > 179.0f )
+		*fov_x = 90.0f; // default value
+
+	x = width / tan( DEG2RAD( *fov_x ) * 0.5f );
+	half_fov_y = atan( height / x );
+
+	return RAD2DEG( half_fov_y ) * 2;
+}
+
+/*
+====================
+V_AdjustFov
+====================
+*/
+static void V_AdjustFov( float *fov_x, float *fov_y, float width, float height, qboolean lock_x )
+{
+	float x, y;
+
+	if( width * 3 == 4 * height || width * 4 == height * 5 )
+	{
+		// 4:3 or 5:4 ratio
+		return;
+	}
+
+	if( lock_x )
+	{
+		*fov_y = 2 * atan((width * 3) / (height * 4) * tan( *fov_y * M_PI_F / 360.0f * 0.5f )) * 360 / M_PI_F;
+		return;
+	}
+
+	y = V_CalcFov( fov_x, 640, 480 );
+	x = *fov_x;
+
+	*fov_x = V_CalcFov( &y, height, width );
+	if( *fov_x < x ) *fov_x = x;
+	else *fov_y = y;
 }
 
 /*
@@ -254,7 +311,7 @@ void V_GetRefParams( ref_params_t *fd, ref_viewpass_t *rvp )
 	rvp->fov_y = V_CalcFov( &rvp->fov_x, clgame.viewport[2], clgame.viewport[3] );
 
 	// adjust FOV for widescreen
-	if( glState.wideScreen && r_adjust_fov->value )
+	if( refState.wideScreen && r_adjust_fov.value )
 		V_AdjustFov( &rvp->fov_x, &rvp->fov_y, clgame.viewport[2], clgame.viewport[3], false );
 
 	rvp->flags = 0;
@@ -273,10 +330,7 @@ V_PreRender
 qboolean V_PreRender( void )
 {
 	// too early
-	if( !glw_state.initialized )
+	if( !ref.initialized )
-		return false;
-
-	if( host.status == HOST_NOFOCUS )
 		return false;
 
 	if( host.status == HOST_SLEEP )
@@ -285,7 +339,7 @@ qboolean V_PreRender( void )
 	// if the screen is disabled (loading plaque is up)
 	if( cls.disable_screen )
 	{
-		if(( host.realtime - cls.disable_screen ) > cl_timeout->value )
+		if(( host.realtime - cls.disable_screen ) > cl_timeout.value )
 		{
 			Con_Reportf( "V_PreRender: loading plaque timed out\n" );
 			cls.disable_screen = 0.0f;
@@ -293,7 +347,9 @@ qboolean V_PreRender( void )
 		return false;
 	}
 
-	R_BeginFrame( !cl.paused && ( cls.state == ca_active ));
+	ref.dllFuncs.R_BeginFrame( !cl.paused && ( cls.state == ca_active ));
+
+	GL_UpdateSwapInterval( );
 
 	return true;
 }
@@ -308,19 +364,21 @@ V_RenderView
 */
 void V_RenderView( void )
 {
-	ref_params_t	rp;
+	// HACKHACK: make ref params static
+	// not really critical but allows client.dll to take address of refdef and don't trigger ASan
+	static ref_params_t	rp;
 	ref_viewpass_t	rvp;
 	int		viewnum = 0;
 
-	if( !cl.video_prepped || ( UI_IsVisible() && !cl.background ))
+	if( !cl.video_prepped || ( !ui_renderworld.value && UI_IsVisible() && !cl.background ))
 		return; // still loading
 
 	V_CalcViewRect ();	// compute viewport rectangle
 	V_SetRefParams( &rp );
 	V_SetupViewModel ();
-	R_Set2DMode( false );
+	ref.dllFuncs.R_Set2DMode( false );
 	SCR_DirtyScreen();
-	GL_BackendStartFrame ();
+	ref.dllFuncs.GL_BackendStartFrame ();
 
 	do
 	{
@@ -330,11 +388,10 @@ void V_RenderView( void )
 
 		if( viewnum == 0 && FBitSet( rvp.flags, RF_ONLY_CLIENTDRAW ))
 		{
-			pglClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
+			ref.dllFuncs.R_ClearScreen();
-			pglClear( GL_COLOR_BUFFER_BIT );
 		}
 
-		R_RenderFrame( &rvp );
+		GL_RenderFrame( &rvp );
 		S_UpdateFrame( &rvp );
 		viewnum++;
 
@@ -342,7 +399,101 @@ void V_RenderView( void )
 
 	// draw debug triangles on a server
 	SV_DrawDebugTriangles ();
-	GL_BackendEndFrame ();
+	ref.dllFuncs.GL_BackendEndFrame ();
+}
+
+#define POINT_SIZE		16.0f
+#define NODE_INTERVAL_X(x)	(x * 16.0f)
+#define NODE_INTERVAL_Y(x)	(x * 16.0f)
+
+void R_DrawLeafNode( float x, float y, float scale )
+{
+	float downScale = scale * 0.25f;// * POINT_SIZE;
+
+	ref.dllFuncs.R_DrawStretchPic( x - downScale * 0.5f, y - downScale * 0.5f, downScale, downScale, 0, 0, 1, 1, R_GetBuiltinTexture( REF_PARTICLE_TEXTURE ) );
+}
+
+void R_DrawNodeConnection( float x, float y, float x2, float y2 )
+{
+	ref.dllFuncs.Begin( TRI_LINES );
+		ref.dllFuncs.Vertex3f( x, y, 0 );
+		ref.dllFuncs.Vertex3f( x2, y2, 0 );
+	ref.dllFuncs.End( );
+}
+
+void R_ShowTree_r( mnode_t *node, float x, float y, float scale, int shownodes, mleaf_t *viewleaf )
+{
+	float	downScale = scale * 0.8f;
+
+	downScale = Q_max( downScale, 1.0f );
+
+	if( !node ) return;
+
+	world.recursion_level++;
+
+	if( node->contents < 0 )
+	{
+		mleaf_t	*leaf = (mleaf_t *)node;
+
+		if( world.recursion_level > world.max_recursion )
+			world.max_recursion = world.recursion_level;
+
+		if( shownodes == 1 )
+		{
+			if( cl.worldmodel->leafs == leaf )
+				ref.dllFuncs.Color4f( 1.0f, 1.0f, 1.0f, 1.0f );
+			else if( viewleaf && viewleaf == leaf )
+				ref.dllFuncs.Color4f( 1.0f, 0.0f, 0.0f, 1.0f );
+			else ref.dllFuncs.Color4f( 0.0f, 1.0f, 0.0f, 1.0f );
+			R_DrawLeafNode( x, y, scale );
+		}
+		world.recursion_level--;
+		return;
+	}
+
+	if( shownodes == 1 )
+	{
+		ref.dllFuncs.Color4f( 0.0f, 0.0f, 1.0f, 1.0f );
+		R_DrawLeafNode( x, y, scale );
+	}
+	else if( shownodes == 2 )
+	{
+		R_DrawNodeConnection( x, y, x - scale, y + scale );
+		R_DrawNodeConnection( x, y, x + scale, y + scale );
+	}
+
+	R_ShowTree_r( node->children[1], x - scale, y + scale, downScale, shownodes, viewleaf );
+	R_ShowTree_r( node->children[0], x + scale, y + scale, downScale, shownodes, viewleaf );
+
+	world.recursion_level--;
+}
+
+void R_ShowTree( void )
+{
+	float	x = (float)((refState.width - (int)POINT_SIZE) >> 1);
+	float	y = NODE_INTERVAL_Y(1.0f);
+	mleaf_t *viewleaf;
+
+	if( !cl.worldmodel || !r_showtree.value )
+		return;
+
+	world.recursion_level = 0;
+	viewleaf = Mod_PointInLeaf( refState.vieworg, cl.worldmodel->nodes );
+
+	//pglEnable( GL_BLEND );
+	//pglBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
+	//pglTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
+
+	//pglLineWidth( 2.0f );
+	ref.dllFuncs.Color4f( 1, 0.7f, 0, 1.0f );
+	//pglDisable( GL_TEXTURE_2D );
+	R_ShowTree_r( cl.worldmodel->nodes, x, y, world.max_recursion * 3.5f, 2, viewleaf );
+	//pglEnable( GL_TEXTURE_2D );
+	//pglLineWidth( 1.0f );
+
+	R_ShowTree_r( cl.worldmodel->nodes, x, y, world.max_recursion * 3.5f, 1, viewleaf );
+
+	Con_NPrintf( 0, "max recursion %d\n", world.max_recursion );
 }
 
 /*
@@ -356,14 +507,14 @@ void V_PostRender( void )
 	static double	oldtime;
 	qboolean		draw_2d = false;
 
-	R_AllowFog( false );
+	ref.dllFuncs.R_AllowFog( false );
-	R_Set2DMode( true );
+	ref.dllFuncs.R_Set2DMode( true );
 
 	if( cls.state == ca_active && cls.signon == SIGNONS && cls.scrshot_action != scrshot_mapshot )
 	{
 		SCR_TileClear();
 		CL_DrawHUD( CL_ACTIVE );
-		VGui_Paint( true );
+		VGui_Paint();
 	}
 
 	switch( cls.scrshot_action )
@@ -379,21 +530,24 @@ void V_PostRender( void )
 	{
 		SCR_RSpeeds();
 		SCR_NetSpeeds();
+		SCR_DrawPos();
 		SCR_DrawNetGraph();
 		SV_DrawOrthoTriangles();
 		CL_DrawDemoRecording();
 		CL_DrawHUD( CL_CHANGELEVEL );
-		R_ShowTextures();
+		ref.dllFuncs.R_ShowTextures();
 		R_ShowTree();
 		Con_DrawConsole();
 		UI_UpdateMenu( host.realtime );
 		Con_DrawVersion();
 		Con_DrawDebug(); // must be last
+		Touch_Draw();
+		OSK_Draw();
 
 		S_ExtraUpdate();
 	}
 
 	SCR_MakeScreenShot();
-	R_AllowFog( true );
+	ref.dllFuncs.R_AllowFog( true );
-	R_EndFrame();
+	ref.dllFuncs.R_EndFrame();
 }

engine/client/client.h

@@ -16,7 +16,8 @@ GNU General Public License for more details.
 #ifndef CLIENT_H
 #define CLIENT_H
 
-#include "mathlib.h"
+#include "xash3d_types.h"
+#include "xash3d_mathlib.h"
 #include "cdll_int.h"
 #include "menu_int.h"
 #include "cl_entity.h"
@@ -31,35 +32,14 @@ GNU General Public License for more details.
 #include "netchan.h"
 #include "net_api.h"
 #include "world.h"
-
+#include "ref_common.h"
-#define MAX_DEMOS		32
+#include "voice.h"
-#define MAX_MOVIES		8
-#define MAX_CDTRACKS	32
-#define MAX_CLIENT_SPRITES	256	// SpriteTextures
-#define MAX_EFRAGS		8192	// Arcane Dimensions required
-#define MAX_REQUESTS	64
-
-// screenshot types
-#define VID_SCREENSHOT	0
-#define VID_LEVELSHOT	1
-#define VID_MINISHOT	2
-#define VID_MAPSHOT		3	// special case for overview layer
-#define VID_SNAPSHOT	4	// save screenshot into root dir and no gamma correction
 
 // client sprite types
 #define SPR_CLIENT		0	// client sprite for temp-entities or user-textures
 #define SPR_HUDSPRITE	1	// hud sprite
 #define SPR_MAPSPRITE	2	// contain overview.bmp that diced into frames 128x128
 
-typedef int		sound_t;
-
-typedef enum
-{
-	DEMO_INACTIVE = 0,
-	DEMO_XASH3D,
-	DEMO_QUAKE1
-} demo_mode;
-
 //=============================================================================
 typedef struct netbandwithgraph_s
 {
@@ -116,7 +96,11 @@ typedef struct
 #define ANGLE_MASK		(ANGLE_BACKUP - 1)
 
 #define CL_UPDATE_MASK	(CL_UPDATE_BACKUP - 1)
+#if XASH_LOW_MEMORY == 2
+#define CL_UPDATE_BACKUP SINGLEPLAYER_BACKUP
+#else
 extern int CL_UPDATE_BACKUP;
+#endif
 
 #define SIGNONS		2		// signon messages to receive before connected
 #define INVALID_HANDLE	0xFFFF		// for XashXT cache system
@@ -124,8 +108,7 @@ extern int CL_UPDATE_BACKUP;
 #define MIN_UPDATERATE	10.0f
 #define MAX_UPDATERATE	102.0f
 
-#define MIN_EX_INTERP	50.0f
+#define MAX_EX_INTERP	0.1f
-#define MAX_EX_INTERP	100.0f
 
 #define CL_MIN_RESEND_TIME	1.5f		// mininum time gap (in seconds) before a subsequent connection request is sent.
 #define CL_MAX_RESEND_TIME	20.0f		// max time.  The cvar cl_resend is bounded by these.
@@ -155,7 +138,7 @@ typedef struct
 	int		light_level;
 	int		waterlevel;
 	int		usehull;
-	int		moving;
+	qboolean	moving;
 	int		pushmsec;
 	int		weapons;
 	float		maxspeed;
@@ -166,13 +149,6 @@ typedef struct
 	float		weaponstarttime;
 } cl_local_data_t;
 
-typedef struct
-{
-	char		name[MAX_OSPATH];
-	char		modelname[MAX_OSPATH];
-	model_t		*model;
-} player_model_t;
-
 typedef struct
 {
 	qboolean		bUsed;
@@ -234,10 +210,9 @@ typedef struct
 						// a lerp point for other data
 	double		oldtime;			// previous cl.time, time-oldtime is used
 						// to decay light values and smooth step ups
-	float		timedelta;		// floating delta between two updates
+	double		timedelta;		// floating delta between two updates
 
 	char		serverinfo[MAX_SERVERINFO_STRING];
-	player_model_t	player_models[MAX_CLIENTS];	// cache of player models
 	player_info_t	players[MAX_CLIENTS];	// collected info about all other players include himself
 	double		lastresourcecheck;
 	string		downloadUrl;
@@ -293,6 +268,8 @@ typedef struct
 	short		decal_index[MAX_DECALS];
 
 	model_t		*worldmodel;			// pointer to world
+
+	int lostpackets;					// count lost packets and show dialog in menu
 } client_t;
 
 /*
@@ -303,16 +280,6 @@ of server connections
 
 ==================================================================
 */
-typedef enum
-{
-	ca_disconnected = 0,// not talking to a server
-	ca_connecting,	// sending request packets to the server
-	ca_connected,	// netchan_t established, waiting for svc_serverdata
-	ca_validate,	// download resources, validating, auth on server
-	ca_active,	// game views should be displayed
-	ca_cinematic,	// playing a cinematic, not connected to a server
-} connstate_t;
-
 typedef enum
 {
 	scrshot_inactive,
@@ -354,31 +321,45 @@ typedef struct
 #define FONT_FIXED      0
 #define FONT_VARIABLE   1
 
+#define FONT_DRAW_HUD      BIT( 0 ) // pass to drawing function to apply hud_scale
+#define FONT_DRAW_UTF8     BIT( 1 ) // call UtfProcessChar
+#define FONT_DRAW_FORCECOL BIT( 2 ) // ignore colorcodes
+#define FONT_DRAW_NORENDERMODE BIT( 3 ) // ignore font's default rendermode
+#define FONT_DRAW_NOLF     BIT( 4 ) // ignore \n
+#define FONT_DRAW_RESETCOLORONLF BIT( 5 ) // yet another flag to simulate consecutive Con_DrawString calls...
+
 typedef struct
 {
 	int      hFontTexture;    // handle to texture
-	wrect_t		fontRc[256];		// rectangles
+	wrect_t  fontRc[256];     // tex coords
-	byte		charWidths[256];
+	float    scale;           // scale factor
-	int		charHeight;
+	byte     charWidths[256]; // scaled widths
-	int		type;
+	int      charHeight;      // scaled height
+	int      type;            // fixed width font or variable
+	int      rendermode;      // default rendermode
+	qboolean	nearest;         // nearest filtering enabled
 	qboolean	valid;           // all rectangles are valid
 } cl_font_t;
 
+typedef struct scissor_state_s
+{
+	int x;
+	int y;
+	int width;
+	int height;
+	qboolean test;
+} scissor_state_t;
+
 typedef struct
 {
+	// scissor test
+	scissor_state_t scissor;
+
 	// temp handle
 	const model_t	*pSprite;			// pointer to current SpriteTexture
 
-	// scissor test
-	int		scissor_x;
-	int		scissor_y;
-	int		scissor_width;
-	int		scissor_height;
-	qboolean		scissor_test;
-	qboolean		adjust_size;		// allow to adjust scale for fonts
-
 	int		renderMode;		// override kRenderMode from TriAPI
-	int		cullMode;			// override CULL FACE from TriAPI
+	TRICULLSTYLE	cullMode;			// override CULL FACE from TriAPI
 
 	// holds text color
 	rgba_t		textColor;
@@ -403,14 +384,10 @@ typedef struct cl_predicted_player_s
 
 typedef struct
 {
-	int		gl_texturenum;	// this is a real texnum
-
 	// scissor test
-	int		scissor_x;
+	scissor_state_t scissor;
-	int		scissor_y;
+
-	int		scissor_width;
+	int		gl_texturenum;	// this is a real texnum
-	int		scissor_height;
-	qboolean		scissor_test;
 
 	// holds text color
 	rgba_t		textColor;
@@ -446,23 +423,6 @@ typedef struct
 	float		applied_angle;
 } screen_shake_t;
 
-typedef struct
-{
-	unsigned short	textures[MAX_SKINS];// alias textures
-	struct mstudiotex_s	*ptexture;	// array of textures with local copy of remapped textures
-	short		numtextures;	// textures count
-	short		topcolor;		// cached value
-	short		bottomcolor;	// cached value
-	model_t		*model;		// for catch model changes
-} remap_info_t;
-
-typedef enum
-{
-	NET_REQUEST_CANCEL = 0,	// request was cancelled for some reasons
-	NET_REQUEST_GAMEUI,		// called from GameUI
-	NET_REQUEST_CLIENT,		// called from Client
-} net_request_type_t;
-
 typedef struct
 {
 	net_response_t		resp;
@@ -480,7 +440,7 @@ typedef struct
 	void		*hInstance;		// pointer to client.dll
 	cldll_func_t	dllFuncs;			// dll exported funcs
 	render_interface_t	drawFuncs;		// custom renderer support
-	byte		*mempool;			// client edicts pool
+	poolhandle_t      mempool;			// client edicts pool
 	string		mapname;			// map name
 	string		maptitle;			// display map title
 	string		itemspath;		// path to items description for auto-complete func
@@ -508,7 +468,7 @@ typedef struct
 
 	string		cdtracks[MAX_CDTRACKS];	// 32 cd-tracks read from cdaudio.txt
 
-	model_t		sprites[MAX_CLIENT_SPRITES];	// client spritetextures
+	model_t		sprites[MAX_CLIENT_SPRITES];	// hud&client spritetexturesz
 	int		viewport[4];		// viewport sizes
 
 	client_draw_t	ds;			// draw2d stuff (hud, weaponmenu etc)
@@ -524,19 +484,20 @@ typedef struct
 	client_textmessage_t *titles;			// title messages, not network messages
 	int		numTitles;
 
-	net_request_type_t	request_type;		// filter the requests
 	net_request_t	net_requests[MAX_REQUESTS];	// no reason to keep more
-	net_request_t	*master_request;		// queued master request
 
 	efrag_t		*free_efrags;		// linked efrags
 	cl_entity_t	viewent;			// viewmodel
+
+	qboolean client_dll_uses_sdl;
 } clgame_static_t;
 
 typedef struct
 {
 	void		*hInstance;		// pointer to client.dll
 	UI_FUNCTIONS	dllFuncs;			// dll exported funcs
-	byte		*mempool;			// client edicts pool
+	UI_EXTENDED_FUNCTIONS dllFuncs2;	// fwgs extension
+	poolhandle_t      mempool;			// client edicts pool
 
 	cl_entity_t	playermodel;		// uiPlayerSetup drawing model
 	player_info_t	playerinfo;		// local playerinfo
@@ -548,9 +509,11 @@ typedef struct
 	ui_globalvars_t	*globals;
 
 	qboolean		drawLogo;			// set to TRUE if logo.avi missed or corrupted
-	long		logo_xres;
+	int		logo_xres;
-	long		logo_yres;
+	int		logo_yres;
 	float		logo_length;
+
+	qboolean use_text_api;
 } gameui_static_t;
 
 typedef struct
@@ -565,14 +528,11 @@ typedef struct
 	float		disable_screen;		// showing loading plaque between levels
 						// or changing rendering dlls
 						// if time gets > 30 seconds ahead, break it
-	int		disable_servercount;	// when we receive a frame and cl.servercount
-						// > cls.disable_servercount, clear disable_screen
-
 	qboolean		draw_changelevel;		// draw changelevel image 'Loading...'
 
 	keydest_t		key_dest;
 
-	byte		*mempool;			// client premamnent pool: edicts etc
+	poolhandle_t      mempool;			// client premamnent pool: edicts etc
 
 	netadr_t		hltv_listen_address;
 
@@ -648,7 +608,7 @@ typedef struct
 
 	// demo recording info must be here, so it isn't clearing on level change
 	qboolean		demorecording;
-	qboolean		demoplayback;
+	int			demoplayback;
 	qboolean		demowaiting;		// don't record until a non-delta message is received
 	qboolean		timedemo;
 	string		demoname;			// for demo looping
@@ -657,6 +617,18 @@ typedef struct
 
 	file_t		*demofile;
 	file_t		*demoheader;		// contain demo startup info in case we record a demo on this level
+	qboolean internetservers_wait;	// internetservers is waiting for dns request
+	qboolean internetservers_pending; // if true, clean master server pings
+	uint32_t internetservers_key;       // compare key to validate master server reply
+	char     internetservers_query[512]; // cached query
+	uint32_t internetservers_query_len;
+
+	// legacy mode support
+	qboolean legacymode;				// one-way 48 protocol compatibility
+	netadr_t legacyserver;
+	int extensions;
+
+	netadr_t serveradr;
 } client_static_t;
 
 #ifdef __cplusplus
@@ -681,46 +653,55 @@ extern convar_t	cl_logocolor;
 extern convar_t	cl_allow_download;
 extern convar_t	cl_allow_upload;
 extern convar_t	cl_download_ingame;
-extern convar_t	*cl_nopred;
+extern convar_t	cl_nopred;
-extern convar_t	*cl_showfps;
+extern convar_t	cl_timeout;
-extern convar_t	*cl_envshot_size;
+extern convar_t	cl_nodelta;
-extern convar_t	*cl_timeout;
+extern convar_t	cl_interp;
-extern convar_t	*cl_nodelta;
+extern convar_t cl_nointerp;
-extern convar_t	*cl_interp;
+extern convar_t	cl_showerror;
-extern convar_t	*cl_showerror;
+extern convar_t	cl_nosmooth;
-extern convar_t	*cl_nosmooth;
+extern convar_t	cl_smoothtime;
-extern convar_t	*cl_smoothtime;
+extern convar_t	cl_crosshair;
-extern convar_t	*cl_crosshair;
+extern convar_t	cl_testlights;
-extern convar_t	*cl_testlights;
+extern convar_t	cl_cmdrate;
-extern convar_t	*cl_cmdrate;
+extern convar_t	cl_updaterate;
-extern convar_t	*cl_updaterate;
+extern convar_t	cl_solid_players;
-extern convar_t	*cl_solid_players;
+extern convar_t	cl_idealpitchscale;
-extern convar_t	*cl_idealpitchscale;
+extern convar_t	cl_allow_levelshots;
-extern convar_t	*cl_allow_levelshots;
+extern convar_t	cl_lightstyle_lerping;
-extern convar_t	*cl_lightstyle_lerping;
+extern convar_t	cl_draw_particles;
-extern convar_t	*cl_draw_particles;
+extern convar_t	cl_draw_tracers;
-extern convar_t	*cl_draw_tracers;
+extern convar_t	cl_levelshot_name;
-extern convar_t	*cl_levelshot_name;
+extern convar_t	cl_draw_beams;
-extern convar_t	*cl_draw_beams;
+extern convar_t	cl_clockreset;
-extern convar_t	*cl_clockreset;
+extern convar_t	cl_fixtimerate;
-extern convar_t	*cl_fixtimerate;
+extern convar_t	hud_fontscale;
-extern convar_t	*gl_showtextures;
+extern convar_t	hud_scale;
-extern convar_t	*cl_bmodelinterp;
+extern convar_t	r_showtextures;
-extern convar_t	*cl_righthand;
+extern convar_t	cl_bmodelinterp;
-extern convar_t	*cl_lw;		// local weapons
+extern convar_t	cl_lw;		// local weapons
-extern convar_t	*cl_showevents;
+extern convar_t	cl_charset;
-extern convar_t	*scr_centertime;
+extern convar_t	cl_trace_messages;
-extern convar_t	*scr_viewsize;
+extern convar_t	cl_trace_events;
-extern convar_t	*scr_loading;
+extern convar_t	hud_utf8;
-extern convar_t	*v_dark;	// start from dark
+extern convar_t	cl_showevents;
-extern convar_t	*net_graph;
+extern convar_t	scr_centertime;
-extern convar_t	*rate;
+extern convar_t	scr_viewsize;
+extern convar_t	scr_loading;
+extern convar_t	v_dark;	// start from dark
+extern convar_t	net_graph;
+extern convar_t	rate;
+extern convar_t	m_ignore;
+extern convar_t	r_showtree;
+extern convar_t	ui_renderworld;
 
 //=============================================================================
 
 void CL_SetLightstyle( int style, const char* s, float f );
 void CL_RunLightStyles( void );
 void CL_DecayLights( void );
+dlight_t *CL_GetDynamicLight( int number );
+dlight_t *CL_GetEntityLight( int number );
 
 //=================================================
 
@@ -737,7 +718,7 @@ void CL_SaveShot_f( void );
 void CL_LevelShot_f( void );
 void CL_SetSky_f( void );
 void SCR_Viewpos_f( void );
-void SCR_TimeRefresh_f( void );
+void CL_WavePlayLen_f( void );
 
 //
 // cl_custom.c
@@ -757,6 +738,11 @@ void CL_ResetFrame( frame_t *frame );
 void CL_WriteMessageHistory( void );
 const char *CL_MsgInfo( int cmd );
 
+//
+// cl_efx.c
+//
+void CL_Particle( const vec3_t org, int color, float life, int zpos, int zvel );
+
 //
 // cl_main.c
 //
@@ -765,7 +751,7 @@ void CL_SendCommand( void );
 void CL_Disconnect_f( void );
 void CL_ProcessFile( qboolean successfully_received, const char *filename );
 void CL_WriteUsercmd( sizebuf_t *msg, int from, int to );
-int CL_GetFragmentSize( void *unused );
+int CL_GetFragmentSize( void *unused , fragsize_t mode );
 qboolean CL_PrecacheResources( void );
 void CL_SetupOverviewParams( void );
 void CL_UpdateFrameLerp( void );
@@ -814,6 +800,20 @@ void CL_ResetEvent( event_info_t *ei );
 word CL_EventIndex( const char *name );
 void CL_FireEvents( void );
 
+//
+// cl_font.c
+//
+qboolean CL_FixedFont( cl_font_t *font );
+qboolean Con_LoadFixedWidthFont( const char *fontname, cl_font_t *font, float scale, int rendermode, uint texFlags );
+qboolean Con_LoadVariableWidthFont( const char *fontname, cl_font_t *font, float scale, int rendermode, uint texFlags );
+void CL_FreeFont( cl_font_t *font );
+int CL_DrawCharacter( float x, float y, int number, rgba_t color, cl_font_t *font, int flags );
+int CL_DrawString( float x, float y, const char *s, rgba_t color, cl_font_t *font, int flags );
+void CL_DrawCharacterLen( cl_font_t *font, int number, int *width, int *height );
+void CL_DrawStringLen( cl_font_t *font, const char *s, int *width, int *height, int flags );
+int CL_DrawStringf( cl_font_t *font, float x, float y, rgba_t color, int flags, const char *fmt, ... ) _format( 6 );
+
+
 //
 // cl_game.c
 //
@@ -824,33 +824,44 @@ void CL_LinkUserMessage( char *pszName, const int svc_num, int iSize );
 void CL_ParseFinaleCutscene( sizebuf_t *msg, int level );
 void CL_ParseTextMessage( sizebuf_t *msg );
 void CL_DrawHUD( int state );
-void CL_InitEdicts( void );
+void CL_InitEdicts( int maxclients );
 void CL_FreeEdicts( void );
 void CL_ClearWorld( void );
 void CL_DrawCenterPrint( void );
 void CL_ClearSpriteTextures( void );
-void CL_FreeEntity( cl_entity_t *pEdict );
 void CL_CenterPrint( const char *text, float y );
 void CL_TextMessageParse( byte *pMemFile, int fileSize );
 client_textmessage_t *CL_TextMessageGet( const char *pName );
-int pfnDecalIndexFromName( const char *szDecalName );
-int pfnIndexFromTrace( struct pmtrace_s *pTrace );
 model_t *CL_ModelHandle( int modelindex );
 void NetAPI_CancelAllRequests( void );
-int CL_FindModelIndex( const char *m );
 cl_entity_t *CL_GetLocalPlayer( void );
 model_t *CL_LoadClientSprite( const char *filename );
 model_t *CL_LoadModel( const char *modelname, int *index );
-HSPRITE pfnSPR_Load( const char *szPicName );
 HSPRITE pfnSPR_LoadExt( const char *szPicName, uint texFlags );
-void PicAdjustSize( float *x, float *y, float *w, float *h );
+void SPR_AdjustSize( float *x, float *y, float *w, float *h );
+void SPR_AdjustTexCoords( float width, float height, float *s1, float *t1, float *s2, float *t2 );
+int CL_GetScreenInfo( SCREENINFO *pscrinfo );
 void CL_FillRGBA( int x, int y, int width, int height, int r, int g, int b, int a );
-void CL_PlayerTrace( float *start, float *end, int traceFlags, int ignore_pe, pmtrace_t *tr );
+pmtrace_t *PM_CL_TraceLine( float *start, float *end, int flags, int usehull, int ignore_pe );
-void CL_PlayerTraceExt( float *start, float *end, int traceFlags, int (*pfnIgnore)( physent_t *pe ), pmtrace_t *tr );
+const char *PM_CL_TraceTexture( int ground, float *vstart, float *vend );
-void CL_SetTraceHull( int hull );
+int PM_CL_PointContents( const float *p, int *truecontents );
+void CL_GetMousePosition( int *mx, int *my ); // TODO: move to input
+cl_entity_t* CL_GetViewModel( void );
+physent_t *pfnGetPhysent( int idx );
+struct msurface_s *pfnTraceSurface( int ground, float *vstart, float *vend );
+movevars_t *pfnGetMoveVars( void );
+void CL_EnableScissor( scissor_state_t *scissor, int x, int y, int width, int height );
+void CL_DisableScissor( scissor_state_t *scissor );
+qboolean CL_Scissor( const scissor_state_t *scissor, float *x, float *y, float *width, float *height, float *u0, float *v0, float *u1, float *v1 );
 
 _inline cl_entity_t *CL_EDICT_NUM( int n )
 {
+	if( !clgame.entities )
+	{
+		Host_Error( "CL_EDICT_NUM: clgame.entities is NULL\n");
+		return NULL;
+	}
+
 	if(( n >= 0 ) && ( n < clgame.maxEntities ))
 		return clgame.entities + n;
 
@@ -861,15 +872,45 @@ _inline cl_entity_t *CL_EDICT_NUM( int n )
 //
 // cl_parse.c
 //
+void CL_ParseSetAngle( sizebuf_t *msg );
+void CL_ParseServerData( sizebuf_t *msg, qboolean legacy );
+void CL_ParseLightStyle( sizebuf_t *msg );
+void CL_UpdateUserinfo( sizebuf_t *msg, qboolean legacy );
+void CL_ParseResource( sizebuf_t *msg );
+void CL_ParseClientData( sizebuf_t *msg );
+void CL_UpdateUserPings( sizebuf_t *msg );
+void CL_ParseParticles( sizebuf_t *msg );
+void CL_ParseRestoreSoundPacket( sizebuf_t *msg );
+void CL_ParseBaseline( sizebuf_t *msg, qboolean legacy );
+void CL_ParseSignon( sizebuf_t *msg );
+void CL_ParseRestore( sizebuf_t *msg );
+void CL_ParseStaticDecal( sizebuf_t *msg );
+void CL_ParseAddAngle( sizebuf_t *msg );
+void CL_RegisterUserMessage( sizebuf_t *msg );
+void CL_ParseMovevars( sizebuf_t *msg );
+void CL_ParseResourceRequest( sizebuf_t *msg );
+void CL_ParseCustomization( sizebuf_t *msg );
+void CL_ParseCrosshairAngle( sizebuf_t *msg );
+void CL_ParseSoundFade( sizebuf_t *msg );
+void CL_ParseFileTransferFailed( sizebuf_t *msg );
+void CL_ParseHLTV( sizebuf_t *msg );
+void CL_ParseDirector( sizebuf_t *msg );
+void CL_ParseResLocation( sizebuf_t *msg );
+void CL_ParseCvarValue( sizebuf_t *msg, const qboolean ext );
 void CL_ParseServerMessage( sizebuf_t *msg, qboolean normal_message );
 void CL_ParseTempEntity( sizebuf_t *msg );
-void CL_StartResourceDownloading( const char *pszMessage, qboolean bCustom );
 qboolean CL_DispatchUserMessage( const char *pszName, int iSize, void *pbuf );
 qboolean CL_RequestMissingResources( void );
 void CL_RegisterResources ( sizebuf_t *msg );
 void CL_ParseViewEntity( sizebuf_t *msg );
 void CL_ParseServerTime( sizebuf_t *msg );
 
+//
+// cl_parse_48.c
+//
+void CL_ParseLegacyServerMessage( sizebuf_t *msg, qboolean normal_message );
+void CL_LegacyPrecache_f( void );
+
 //
 // cl_scrn.c
 //
@@ -886,6 +927,7 @@ void SCR_MakeLevelShot( void );
 void SCR_NetSpeeds( void );
 void SCR_RSpeeds( void );
 void SCR_DrawFPS( int height );
+void SCR_DrawPos( void );
 
 //
 // cl_netgraph.c
@@ -913,10 +955,8 @@ void CL_PredictMovement( qboolean repredicting );
 void CL_CheckPredictionError( void );
 qboolean CL_IsPredicted( void );
 int CL_TruePointContents( const vec3_t p );
-int CL_PointContents( const vec3_t p );
 int CL_WaterEntity( const float *rgflPos );
 cl_entity_t *CL_GetWaterEntity( const float *rgflPos );
-void CL_SetupPMove( playermove_t *pmove, local_state_t *from, usercmd_t *ucmd, qboolean runfuncs, double time );
 int CL_TestLine( const vec3_t start, const vec3_t end, int flags );
 pmtrace_t *CL_VisTraceLine( vec3_t start, vec3_t end, int flags );
 pmtrace_t CL_TraceLine( vec3_t start, vec3_t end, int flags );
@@ -925,7 +965,6 @@ void CL_PopTraceBounds( void );
 void CL_MoveSpectatorCamera( void );
 void CL_SetLastUpdate( void );
 void CL_RedoPrediction( void );
-void CL_ClearPhysEnts( void );
 void CL_PushPMStates( void );
 void CL_PopPMStates( void );
 void CL_SetUpPlayerPrediction( int dopred, int bIncludeLocalClient );
@@ -935,14 +974,11 @@ void CL_SetUpPlayerPrediction( int dopred, int bIncludeLocalClient );
 //
 void CL_ParseQuakeMessage( sizebuf_t *msg, qboolean normal_message );
 
-//
-// cl_studio.c
-//
-void CL_InitStudioAPI( void );
-
 //
 // cl_frame.c
 //
+struct channel_s;
+struct rawchan_s;
 int CL_ParsePacketEntities( sizebuf_t *msg, qboolean delta );
 qboolean CL_AddVisibleEntity( cl_entity_t *ent, int entityType );
 void CL_ResetLatchedVars( cl_entity_t *ent, qboolean full_reset );
@@ -960,33 +996,42 @@ void CL_EmitEntities( void );
 // cl_remap.c
 //
 remap_info_t *CL_GetRemapInfoForEntity( cl_entity_t *e );
-void CL_AllocRemapInfo( int topcolor, int bottomcolor );
+void CL_AllocRemapInfo( cl_entity_t *entity, model_t *model, int topcolor, int bottomcolor );
 void CL_FreeRemapInfo( remap_info_t *info );
-void R_StudioSetRemapColors( int top, int bottom );
+void CL_UpdateRemapInfo( cl_entity_t *ent, int topcolor, int bottomcolor );
-void CL_UpdateRemapInfo( int topcolor, int bottomcolor );
 void CL_ClearAllRemaps( void );
 
+//
+// cl_render.c
+//
+qboolean R_InitRenderAPI( void );
+intptr_t CL_RenderGetParm( const int parm, const int arg, const qboolean checkRef );
+lightstyle_t *CL_GetLightStyle( int number );
+int R_FatPVS( const vec3_t org, float radius, byte *visbuffer, qboolean merge, qboolean fullvis );
+const ref_overview_t *GL_GetOverviewParms( void );
+
+//
+// cl_efrag.c
+//
+void R_StoreEfrags( efrag_t **ppefrag, int framecount );
+void R_AddEfrags( cl_entity_t *ent );
 //
 // cl_tent.c
 //
-int CL_AddEntity( int entityType, cl_entity_t *pEnt );
+struct particle_s;
 void CL_WeaponAnim( int iAnim, int body );
 void CL_ClearEffects( void );
 void CL_ClearEfrags( void );
 void CL_TestLights( void );
-void CL_DrawParticlesExternal( const ref_viewpass_t *rvp, qboolean trans_pass, float frametime );
 void CL_FireCustomDecal( int textureIndex, int entityIndex, int modelIndex, float *pos, int flags, float scale );
 void CL_DecalShoot( int textureIndex, int entityIndex, int modelIndex, float *pos, int flags );
 void CL_PlayerDecal( int playerIndex, int textureIndex, int entityIndex, float *pos );
 void R_FreeDeadParticles( struct particle_s **ppparticles );
 void CL_AddClientResource( const char *filename, int type );
 void CL_AddClientResources( void );
-int CL_FxBlend( cl_entity_t *e );
 void CL_InitParticles( void );
 void CL_ClearParticles( void );
 void CL_FreeParticles( void );
-void CL_DrawParticles( double frametime );
-void CL_DrawTracers( double frametime );
 void CL_InitTempEnts( void );
 void CL_ClearTempEnts( void );
 void CL_FreeTempEnts( void );
@@ -994,20 +1039,21 @@ void CL_TempEntUpdate( void );
 void CL_InitViewBeams( void );
 void CL_ClearViewBeams( void );
 void CL_FreeViewBeams( void );
-void CL_DrawBeams( int fTrans );
+cl_entity_t *R_BeamGetEntity( int index );
-void CL_AddCustomBeam( cl_entity_t *pEnvBeam );
 void CL_KillDeadBeams( cl_entity_t *pDeadEntity );
 void CL_ParseViewBeam( sizebuf_t *msg, int beamType );
 void CL_LoadClientSprites( void );
 void CL_ReadPointFile_f( void );
+void CL_DrawEFX( float time, qboolean fTrans );
+void CL_ThinkParticle( double frametime, particle_t *p );
 void CL_ReadLineFile_f( void );
 void CL_RunLightStyles( void );
 
 //
 // console.c
 //
-extern convar_t *con_fontsize;
+extern convar_t con_fontsize;
-qboolean Con_Visible( void );
+int Con_Visible( void );
 qboolean Con_FixedFont( void );
 void Con_VidInit( void );
 void Con_Shutdown( void );
@@ -1017,25 +1063,33 @@ void Con_DrawDebug( void );
 void Con_RunConsole( void );
 void Con_DrawConsole( void );
 void Con_DrawVersion( void );
-void Con_DrawStringLen( const char *pText, int *length, int *height );
+int Con_UtfProcessChar( int in );
-int Con_DrawString( int x, int y, const char *string, rgba_t setColor );
+int Con_UtfProcessCharForce( int in );
-int Con_DrawCharacter( int x, int y, int number, rgba_t color );
+int Con_UtfMoveLeft( char *str, int pos );
-void Con_DrawCharacterLen( int number, int *width, int *height );
+int Con_UtfMoveRight( char *str, int pos, int length );
 void Con_DefaultColor( int r, int g, int b );
 void Con_InvalidateFonts( void );
-void Con_SetFont( int fontNum );
+cl_font_t *Con_GetCurFont( void );
+cl_font_t *Con_GetFont( int num );
+void Con_DrawCharacterLen( int number, int *width, int *height );
+int Con_DrawString( int x, int y, const char *string, rgba_t setColor ); // legacy, use cl_font.c
+void GAME_EXPORT Con_DrawStringLen( const char *pText, int *length, int *height ); // legacy, use cl_font.c
 void Con_CharEvent( int key );
 void Con_RestoreFont( void );
 void Key_Console( int key );
 void Key_Message( int key );
 void Con_FastClose( void );
+void Con_Bottom( void );
+void Con_Top( void );
+void Con_PageDown( int lines );
+void Con_PageUp( int lines );
 
 //
 // s_main.c
 //
 void S_StreamRawSamples( int samples, int rate, int width, int channels, const byte *data );
 void S_StreamAviSamples( void *Avi, int entnum, float fvol, float attn, float synctime );
-void S_StartBackgroundTrack( const char *intro, const char *loop, long position, qboolean fullpath );
+void S_StartBackgroundTrack( const char *intro, const char *loop, int position, qboolean fullpath );
 void S_StopBackgroundTrack( void );
 void S_StreamSetPause( int pause );
 void S_StartStreaming( void );
@@ -1069,12 +1123,34 @@ qboolean UI_CreditsActive( void );
 void UI_CharEvent( int key );
 qboolean UI_MouseInRect( void );
 qboolean UI_IsVisible( void );
+void UI_ResetPing( void );
+void UI_ShowUpdateDialog( qboolean preferStore );
+void UI_ShowMessageBox( const char *text );
+void UI_AddTouchButtonToList( const char *name, const char *texture, const char *command, unsigned char *color, int flags );
+void UI_ConnectionProgress_Disconnect( void );
+void UI_ConnectionProgress_Download( const char *pszFileName, const char *pszServerName, const char *pszServerPath, int iCurrent, int iTotal, const char *comment );
+void UI_ConnectionProgress_DownloadEnd( void );
+void UI_ConnectionProgress_Precache( void );
+void UI_ConnectionProgress_Connect( const char *server );
+void UI_ConnectionProgress_ChangeLevel( void );
+void UI_ConnectionProgress_ParseServerInfo( const char *server );
 void pfnPIC_Set( HIMAGE hPic, int r, int g, int b, int a );
 void pfnPIC_Draw( int x, int y, int width, int height, const wrect_t *prc );
 void pfnPIC_DrawTrans( int x, int y, int width, int height, const wrect_t *prc );
 void pfnPIC_DrawHoles( int x, int y, int width, int height, const wrect_t *prc );
 void pfnPIC_DrawAdditive( int x, int y, int width, int height, const wrect_t *prc );
 
+//
+// cl_mobile.c
+//
+qboolean Mobile_Init( void );
+void Mobile_Shutdown( void );
+
+//
+// cl_securedstub.c
+//
+void CL_GetSecuredClientAPI( CL_EXPORT_FUNCS F );
+
 //
 // cl_video.c
 //
@@ -1087,4 +1163,26 @@ void SCR_RunCinematic( void );
 void SCR_StopCinematic( void );
 void CL_PlayVideo_f( void );
 
+
+//
+// keys.c
+//
+int Key_IsDown( int keynum );
+void Key_Event( int key, int down );
+void Key_Init( void );
+void Key_WriteBindings( file_t *f );
+const char *Key_GetBinding( int keynum );
+void Key_SetBinding( int keynum, const char *binding );
+void Key_ClearStates( void );
+const char *Key_KeynumToString( int keynum );
+int Key_StringToKeynum( const char *str );
+int Key_GetKey( const char *binding );
+void Key_EnumCmds_f( void );
+void Key_SetKeyDest( int key_dest );
+void Key_EnableTextInput( qboolean enable, qboolean force );
+int Key_ToUpper( int key );
+void OSK_Draw( void );
+
+extern rgba_t g_color_table[8];
+
 #endif//CLIENT_H

engine/client/gl_frustum.c

@@ -1,355 +0,0 @@
-/*
-gl_frustum.cpp - frustum test implementation
-Copyright (C) 2016 Uncle Mike
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-*/
-
-#include "common.h"
-#include "gl_local.h"
-#include "mathlib.h"
-
-void GL_FrustumEnablePlane( gl_frustum_t *out, int side )
-{
-	Assert( side >= 0 && side < FRUSTUM_PLANES );
-
-	// make sure what plane is ready
-	if( !VectorIsNull( out->planes[side].normal ))
-		SetBits( out->clipFlags, BIT( side ));
-}
-
-void GL_FrustumDisablePlane( gl_frustum_t *out, int side )
-{
-	Assert( side >= 0 && side < FRUSTUM_PLANES );
-	ClearBits( out->clipFlags, BIT( side ));
-}
-
-void GL_FrustumSetPlane( gl_frustum_t *out, int side, const vec3_t vecNormal, float flDist )
-{
-	Assert( side >= 0 && side < FRUSTUM_PLANES );
-
-	out->planes[side].type = PlaneTypeForNormal( vecNormal );
-	out->planes[side].signbits = SignbitsForPlane( vecNormal );
-	VectorCopy( vecNormal, out->planes[side].normal );
-	out->planes[side].dist = flDist;
-
-	SetBits( out->clipFlags, BIT( side ));
-}
-
-void GL_FrustumNormalizePlane( gl_frustum_t *out, int side )
-{
-	float	length;
-
-	Assert( side >= 0 && side < FRUSTUM_PLANES );
-
-	// normalize
-	length = VectorLength( out->planes[side].normal );
-
-	if( length )
-	{
-		float ilength = (1.0f / length);
-		out->planes[side].normal[0] *= ilength;
-		out->planes[side].normal[1] *= ilength;
-		out->planes[side].normal[2] *= ilength;
-		out->planes[side].dist *= ilength;
-	}
-
-	out->planes[side].type = PlaneTypeForNormal( out->planes[side].normal );
-	out->planes[side].signbits = SignbitsForPlane( out->planes[side].normal );
-
-	SetBits( out->clipFlags, BIT( side ));
-}
-
-void GL_FrustumInitProj( gl_frustum_t *out, float flZNear, float flZFar, float flFovX, float flFovY )
-{
-	float	xs, xc;
-	vec3_t	farpoint, nearpoint;
-	vec3_t	normal, iforward;	
-
-	// horizontal fov used for left and right planes
-	SinCos( DEG2RAD( flFovX ) * 0.5f, &xs, &xc );
-
-	// setup left plane
-	VectorMAM( xs, RI.cull_vforward, -xc, RI.cull_vright, normal ); 
-	GL_FrustumSetPlane( out, FRUSTUM_LEFT, normal, DotProduct( RI.cullorigin, normal ));
-
-	// setup right plane
-	VectorMAM( xs, RI.cull_vforward, xc, RI.cull_vright, normal ); 
-	GL_FrustumSetPlane( out, FRUSTUM_RIGHT, normal, DotProduct( RI.cullorigin, normal ));
-
-	// vertical fov used for top and bottom planes
-	SinCos( DEG2RAD( flFovY ) * 0.5f, &xs, &xc );
-	VectorNegate( RI.cull_vforward, iforward );
-
-	// setup bottom plane
-	VectorMAM( xs, RI.cull_vforward, -xc, RI.cull_vup, normal ); 
-	GL_FrustumSetPlane( out, FRUSTUM_BOTTOM, normal, DotProduct( RI.cullorigin, normal ));
-
-	// setup top plane
-	VectorMAM( xs, RI.cull_vforward, xc, RI.cull_vup, normal ); 
-	GL_FrustumSetPlane( out, FRUSTUM_TOP, normal, DotProduct( RI.cullorigin, normal ));
-
-	// setup far plane
-	VectorMA( RI.cullorigin, flZFar, RI.cull_vforward, farpoint );
-	GL_FrustumSetPlane( out, FRUSTUM_FAR, iforward, DotProduct( iforward, farpoint ));
-
-	// no need to setup backplane for general view.
-	if( flZNear == 0.0f ) return;
-
-	// setup near plane
-	VectorMA( RI.cullorigin, flZNear, RI.cull_vforward, nearpoint );
-	GL_FrustumSetPlane( out, FRUSTUM_NEAR, RI.cull_vforward, DotProduct( RI.cull_vforward, nearpoint ));
-}
-
-void GL_FrustumInitOrtho( gl_frustum_t *out, float xLeft, float xRight, float yTop, float yBottom, float flZNear, float flZFar )
-{
-	vec3_t	iforward, iright, iup;
-
-	// setup the near and far planes
-	float orgOffset = DotProduct( RI.cullorigin, RI.cull_vforward );
-	VectorNegate( RI.cull_vforward, iforward );
-
-	// because quake ortho is inverted and far and near should be swaped
-	GL_FrustumSetPlane( out, FRUSTUM_FAR, iforward, -flZNear - orgOffset );
-	GL_FrustumSetPlane( out, FRUSTUM_NEAR, RI.cull_vforward, flZFar + orgOffset );
-
-	// setup left and right planes
-	orgOffset = DotProduct( RI.cullorigin, RI.cull_vright );
-	VectorNegate( RI.cull_vright, iright );
-
-	GL_FrustumSetPlane( out, FRUSTUM_LEFT, RI.cull_vright, xLeft + orgOffset );
-	GL_FrustumSetPlane( out, FRUSTUM_RIGHT, iright, -xRight - orgOffset );
-
-	// setup top and buttom planes
-	orgOffset = DotProduct( RI.cullorigin, RI.cull_vup );
-	VectorNegate( RI.cull_vup, iup );
-
-	GL_FrustumSetPlane( out, FRUSTUM_TOP, RI.cull_vup, yTop + orgOffset );
-	GL_FrustumSetPlane( out, FRUSTUM_BOTTOM, iup, -yBottom - orgOffset );
-}
-
-void GL_FrustumInitBox( gl_frustum_t *out, const vec3_t org, float radius )
-{
-	vec3_t	normal;
-	int	i;
-
-	for( i = 0; i < FRUSTUM_PLANES; i++ )
-	{
-		// setup normal for each direction
-		VectorClear( normal );
-		normal[((i >> 1) + 1) % 3] = (i & 1) ? 1.0f : -1.0f;
-		GL_FrustumSetPlane( out, i, normal, DotProduct( org, normal ) - radius );
-	}
-}
-
-void GL_FrustumInitProjFromMatrix( gl_frustum_t *out, const matrix4x4 projection )
-{
-	int	i;
-
-	// left
-	out->planes[FRUSTUM_LEFT].normal[0] =	projection[0][3] + projection[0][0];
-	out->planes[FRUSTUM_LEFT].normal[1] =	projection[1][3] + projection[1][0];
-	out->planes[FRUSTUM_LEFT].normal[2] =	projection[2][3] + projection[2][0];
-	out->planes[FRUSTUM_LEFT].dist =	-(projection[3][3] + projection[3][0]);
-
-	// right
-	out->planes[FRUSTUM_RIGHT].normal[0] =	projection[0][3] - projection[0][0];
-	out->planes[FRUSTUM_RIGHT].normal[1] =	projection[1][3] - projection[1][0];
-	out->planes[FRUSTUM_RIGHT].normal[2] =	projection[2][3] - projection[2][0];
-	out->planes[FRUSTUM_RIGHT].dist =	-(projection[3][3] - projection[3][0]);
-
-	// bottom
-	out->planes[FRUSTUM_BOTTOM].normal[0] =	projection[0][3] + projection[0][1];
-	out->planes[FRUSTUM_BOTTOM].normal[1] =	projection[1][3] + projection[1][1];
-	out->planes[FRUSTUM_BOTTOM].normal[2] =	projection[2][3] + projection[2][1];
-	out->planes[FRUSTUM_BOTTOM].dist =	-(projection[3][3] + projection[3][1]);
-
-	// top
-	out->planes[FRUSTUM_TOP].normal[0] =	projection[0][3] - projection[0][1];
-	out->planes[FRUSTUM_TOP].normal[1] =	projection[1][3] - projection[1][1];
-	out->planes[FRUSTUM_TOP].normal[2] =	projection[2][3] - projection[2][1];
-	out->planes[FRUSTUM_TOP].dist =	-(projection[3][3] - projection[3][1]);
-
-	// near
-	out->planes[FRUSTUM_NEAR].normal[0] =	projection[0][3] + projection[0][2];
-	out->planes[FRUSTUM_NEAR].normal[1] =	projection[1][3] + projection[1][2];
-	out->planes[FRUSTUM_NEAR].normal[2] =	projection[2][3] + projection[2][2];
-	out->planes[FRUSTUM_NEAR].dist =	-(projection[3][3] + projection[3][2]);
-
-	// far
-	out->planes[FRUSTUM_FAR].normal[0] =	projection[0][3] - projection[0][2];
-	out->planes[FRUSTUM_FAR].normal[1] =	projection[1][3] - projection[1][2];
-	out->planes[FRUSTUM_FAR].normal[2] =	projection[2][3] - projection[2][2];
-	out->planes[FRUSTUM_FAR].dist =	-(projection[3][3] - projection[3][2]);
-
-	for( i = 0; i < FRUSTUM_PLANES; i++ )
-	{
-		GL_FrustumNormalizePlane( out, i );
-	}
-}
-
-void GL_FrustumComputeCorners( gl_frustum_t *out, vec3_t corners[8] )
-{
-	memset( corners, 0, sizeof( corners ));
-
-	PlanesGetIntersectionPoint( &out->planes[FRUSTUM_LEFT], &out->planes[FRUSTUM_TOP], &out->planes[FRUSTUM_FAR], corners[0] );
-	PlanesGetIntersectionPoint( &out->planes[FRUSTUM_RIGHT], &out->planes[FRUSTUM_TOP], &out->planes[FRUSTUM_FAR], corners[1] );
-	PlanesGetIntersectionPoint( &out->planes[FRUSTUM_LEFT], &out->planes[FRUSTUM_BOTTOM], &out->planes[FRUSTUM_FAR], corners[2] );
-	PlanesGetIntersectionPoint( &out->planes[FRUSTUM_RIGHT], &out->planes[FRUSTUM_BOTTOM], &out->planes[FRUSTUM_FAR], corners[3] );
-
-	if( FBitSet( out->clipFlags, BIT( FRUSTUM_NEAR )))
-	{
-		PlanesGetIntersectionPoint( &out->planes[FRUSTUM_LEFT], &out->planes[FRUSTUM_TOP], &out->planes[FRUSTUM_NEAR], corners[4] );
-		PlanesGetIntersectionPoint( &out->planes[FRUSTUM_RIGHT], &out->planes[FRUSTUM_TOP], &out->planes[FRUSTUM_NEAR], corners[5] );
-		PlanesGetIntersectionPoint( &out->planes[FRUSTUM_LEFT], &out->planes[FRUSTUM_BOTTOM], &out->planes[FRUSTUM_NEAR], corners[6] );
-		PlanesGetIntersectionPoint( &out->planes[FRUSTUM_RIGHT], &out->planes[FRUSTUM_BOTTOM], &out->planes[FRUSTUM_NEAR], corners[7] );
-	}
-	else
-	{
-		PlanesGetIntersectionPoint( &out->planes[FRUSTUM_LEFT], &out->planes[FRUSTUM_RIGHT], &out->planes[FRUSTUM_TOP], corners[4] );
-		VectorCopy( corners[4], corners[5] );
-		VectorCopy( corners[4], corners[6] );
-		VectorCopy( corners[4], corners[7] );
-	}
-}
-
-void GL_FrustumComputeBounds( gl_frustum_t *out, vec3_t mins, vec3_t maxs )
-{
-	vec3_t	corners[8];
-	int	i;
-
-	GL_FrustumComputeCorners( out, corners );
-
-	ClearBounds( mins, maxs );
-
-	for( i = 0; i < 8; i++ )
-		AddPointToBounds( corners[i], mins, maxs );
-}
-
-void GL_FrustumDrawDebug( gl_frustum_t *out )
-{
-	vec3_t	bbox[8];
-	int	i;
-
-	GL_FrustumComputeCorners( out, bbox );
-
-	// g-cont. frustum must be yellow :-)
-	pglColor4f( 1.0f, 1.0f, 0.0f, 1.0f );
-	pglDisable( GL_TEXTURE_2D );
-	pglBegin( GL_LINES );
-
-	for( i = 0; i < 2; i += 1 )
-	{
-		pglVertex3fv( bbox[i+0] );
-		pglVertex3fv( bbox[i+2] );
-		pglVertex3fv( bbox[i+4] );
-		pglVertex3fv( bbox[i+6] );
-		pglVertex3fv( bbox[i+0] );
-		pglVertex3fv( bbox[i+4] );
-		pglVertex3fv( bbox[i+2] );
-		pglVertex3fv( bbox[i+6] );
-		pglVertex3fv( bbox[i*2+0] );
-		pglVertex3fv( bbox[i*2+1] );
-		pglVertex3fv( bbox[i*2+4] );
-		pglVertex3fv( bbox[i*2+5] );
-	}
-
-	pglEnd();
-	pglEnable( GL_TEXTURE_2D );
-}
-
-// cull methods
-qboolean GL_FrustumCullBox( gl_frustum_t *out, const vec3_t mins, const vec3_t maxs, int userClipFlags )
-{
-	int	iClipFlags;
-	int	i, bit;
-
-	if( r_nocull->value )
-		return false;
-
-	if( userClipFlags != 0 )
-		iClipFlags = userClipFlags;
-	else iClipFlags = out->clipFlags;
-
-	for( i = FRUSTUM_PLANES, bit = 1; i > 0; i--, bit <<= 1 )
-	{
-		const mplane_t	*p = &out->planes[FRUSTUM_PLANES - i];
-
-		if( !FBitSet( iClipFlags, bit ))
-			continue;
-
-		switch( p->signbits )
-		{
-		case 0:
-			if( p->normal[0] * maxs[0] + p->normal[1] * maxs[1] + p->normal[2] * maxs[2] < p->dist )
-				return true;
-			break;
-		case 1:
-			if( p->normal[0] * mins[0] + p->normal[1] * maxs[1] + p->normal[2] * maxs[2] < p->dist )
-				return true;
-			break;
-		case 2:
-			if( p->normal[0] * maxs[0] + p->normal[1] * mins[1] + p->normal[2] * maxs[2] < p->dist )
-				return true;
-			break;
-		case 3:
-			if( p->normal[0] * mins[0] + p->normal[1] * mins[1] + p->normal[2] * maxs[2] < p->dist )
-				return true;
-			break;
-		case 4:
-			if( p->normal[0] * maxs[0] + p->normal[1] * maxs[1] + p->normal[2] * mins[2] < p->dist )
-				return true;
-			break;
-		case 5:
-			if( p->normal[0] * mins[0] + p->normal[1] * maxs[1] + p->normal[2] * mins[2] < p->dist )
-				return true;
-			break;
-		case 6:
-			if( p->normal[0] * maxs[0] + p->normal[1] * mins[1] + p->normal[2] * mins[2] < p->dist )
-				return true;
-			break;
-		case 7:
-			if( p->normal[0] * mins[0] + p->normal[1] * mins[1] + p->normal[2] * mins[2] < p->dist )
-				return true;
-			break;
-		default:
-			return false;
-		}
-	}
-
-	return false;
-}
-
-qboolean GL_FrustumCullSphere( gl_frustum_t *out, const vec3_t center, float radius, int userClipFlags )
-{
-	int	iClipFlags;
-	int	i, bit;
-
-	if( r_nocull->value )
-		return false;
-
-	if( userClipFlags != 0 )
-		iClipFlags = userClipFlags;
-	else iClipFlags = out->clipFlags;
-
-	for( i = FRUSTUM_PLANES, bit = 1; i > 0; i--, bit <<= 1 )
-	{
-		const mplane_t *p = &out->planes[FRUSTUM_PLANES - i];
-
-		if( !FBitSet( iClipFlags, bit ))
-			continue;
-
-		if( DotProduct( center, p->normal ) - p->dist <= -radius )
-			return true;
-	}
-
-	return false;
-}

engine/client/in_joy.c

@@ -0,0 +1,438 @@
+/*
+joyinput.c - joystick common input code
+
+Copyright (C) 2016 a1batross
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+*/
+
+#include "common.h"
+#include "input.h"
+#include "keydefs.h"
+#include "client.h"
+#include "platform/platform.h"
+
+#ifndef SHRT_MAX
+#define SHRT_MAX 0x7FFF
+#endif
+
+#define MAX_AXES JOY_AXIS_NULL
+
+// index - axis num come from event
+// value - inner axis
+static engineAxis_t joyaxesmap[MAX_AXES] =
+{
+	JOY_AXIS_SIDE,  // left stick, x
+	JOY_AXIS_FWD,   // left stick, y
+	JOY_AXIS_PITCH, // right stick, y
+	JOY_AXIS_YAW,   // right stick, x
+	JOY_AXIS_RT,    // right trigger
+	JOY_AXIS_LT     // left trigger
+};
+
+static struct joy_axis_s
+{
+	short val;
+	short prevval;
+} joyaxis[MAX_AXES] = { 0 };
+static byte currentbinding; // add posibility to remap keys, to place it in joykeys[]
+static qboolean joy_initialized;
+
+static CVAR_DEFINE_AUTO( joy_pitch,   "100.0", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "joystick pitch sensitivity" );
+static CVAR_DEFINE_AUTO( joy_yaw,     "100.0", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "joystick yaw sensitivity" );
+static CVAR_DEFINE_AUTO( joy_side,    "1.0", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "joystick side sensitivity. Values from -1.0 to 1.0" );
+static CVAR_DEFINE_AUTO( joy_forward, "1.0", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "joystick forward sensitivity. Values from -1.0 to 1.0" );
+static CVAR_DEFINE_AUTO( joy_lt_threshold, "16384", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "left trigger threshold. Value from 0 to 32767");
+static CVAR_DEFINE_AUTO( joy_rt_threshold, "16384", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "right trigger threshold. Value from 0 to 32767" );
+static CVAR_DEFINE_AUTO( joy_side_key_threshold, "24576", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "side axis key event emit threshold. Value from 0 to 32767" );
+static CVAR_DEFINE_AUTO( joy_forward_key_threshold, "24576", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "forward axis key event emit threshold. Value from 0 to 32767");
+static CVAR_DEFINE_AUTO( joy_side_deadzone, DEFAULT_JOY_DEADZONE, FCVAR_ARCHIVE | FCVAR_FILTERABLE, "side axis deadzone. Value from 0 to 32767" );
+static CVAR_DEFINE_AUTO( joy_forward_deadzone, DEFAULT_JOY_DEADZONE, FCVAR_ARCHIVE | FCVAR_FILTERABLE, "forward axis deadzone. Value from 0 to 32767");
+static CVAR_DEFINE_AUTO( joy_pitch_deadzone, DEFAULT_JOY_DEADZONE, FCVAR_ARCHIVE | FCVAR_FILTERABLE, "pitch axis deadzone. Value from 0 to 32767");
+static CVAR_DEFINE_AUTO( joy_yaw_deadzone, DEFAULT_JOY_DEADZONE, FCVAR_ARCHIVE | FCVAR_FILTERABLE, "yaw axis deadzone. Value from 0 to 32767" );
+static CVAR_DEFINE_AUTO( joy_axis_binding, "sfpyrl", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "axis hardware id to engine inner axis binding, "
+	"s - side, f - forward, y - yaw, p - pitch, r - left trigger, l - right trigger" );
+static CVAR_DEFINE_AUTO( joy_found, "0", FCVAR_READ_ONLY, "is joystick is connected" );
+static CVAR_DEFINE_AUTO( joy_index, "0", FCVAR_READ_ONLY, "current active joystick" );
+CVAR_DEFINE_AUTO( joy_enable, "1", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "enable joystick" );
+
+/*
+============
+Joy_IsActive
+============
+*/
+qboolean Joy_IsActive( void )
+{
+	return joy_found.value && joy_enable.value;
+}
+
+/*
+============
+Joy_HatMotionEvent
+
+DPad events
+============
+*/
+void Joy_HatMotionEvent( byte hat, byte value )
+{
+	struct
+	{
+		int mask;
+		int key;
+	} keys[] =
+	{
+		{ JOY_HAT_UP, K_UPARROW },
+		{ JOY_HAT_DOWN, K_DOWNARROW },
+		{ JOY_HAT_LEFT, K_LEFTARROW },
+		{ JOY_HAT_RIGHT, K_RIGHTARROW },
+	};
+	int i;
+
+	if( !joy_found.value )
+		return;
+
+	for( i = 0; i < ARRAYSIZE( keys ); i++ )
+	{
+		if( value & keys[i].mask )
+		{
+			if( !Key_IsDown( keys[i].key ))
+				Key_Event( keys[i].key, true );
+		}
+		else
+		{
+			if( Key_IsDown( keys[i].key ))
+				Key_Event( keys[i].key, false );
+		}
+	}
+}
+
+/*
+=============
+Joy_ProcessTrigger
+=============
+*/
+static void Joy_ProcessTrigger( const engineAxis_t engineAxis, short value )
+{
+	int trigButton = 0, trigThreshold = 0;
+
+	switch( engineAxis )
+	{
+	case JOY_AXIS_RT:
+		trigButton = K_JOY2;
+		trigThreshold = joy_rt_threshold.value;
+		break;
+	case JOY_AXIS_LT:
+		trigButton = K_JOY1;
+		trigThreshold = joy_lt_threshold.value;
+		break;
+	default:
+		Con_Reportf( S_ERROR  "Joy_ProcessTrigger: invalid axis = %i", engineAxis );
+		break;
+	}
+
+	// update axis values
+	joyaxis[engineAxis].prevval = joyaxis[engineAxis].val;
+	joyaxis[engineAxis].val = value;
+
+	if( joyaxis[engineAxis].val > trigThreshold &&
+		joyaxis[engineAxis].prevval <= trigThreshold ) // ignore random press
+	{
+		Key_Event( trigButton, true );
+	}
+	else if( joyaxis[engineAxis].val < trigThreshold &&
+			 joyaxis[engineAxis].prevval >= trigThreshold ) // we're unpressing (inverted)
+	{
+		Key_Event( trigButton, false );
+	}
+}
+
+static int Joy_GetHatValueForAxis( const engineAxis_t engineAxis )
+{
+	int threshold, negative, positive;
+
+	switch( engineAxis )
+	{
+	case JOY_AXIS_SIDE:
+		threshold = joy_side_key_threshold.value;
+		negative = JOY_HAT_LEFT;
+		positive = JOY_HAT_RIGHT;
+		break;
+	case JOY_AXIS_FWD:
+		threshold = joy_side_key_threshold.value;
+		negative = JOY_HAT_UP;
+		positive = JOY_HAT_DOWN;
+		break;
+	default:
+		ASSERT( false ); // only fwd/side axes can emit key events
+		return 0;
+	}
+
+	// similar code in Joy_ProcessTrigger
+	if( joyaxis[engineAxis].val > threshold &&
+		joyaxis[engineAxis].prevval <= threshold ) // ignore random press
+	{
+		return positive;
+	}
+	if( joyaxis[engineAxis].val < -threshold &&
+		joyaxis[engineAxis].prevval >= -threshold ) // we're unpressing (inverted)
+	{
+		return negative;
+	}
+	return 0;
+}
+
+/*
+=============
+Joy_ProcessStick
+=============
+*/
+static void Joy_ProcessStick( const engineAxis_t engineAxis, short value )
+{
+	int deadzone = 0;
+
+	switch( engineAxis )
+	{
+	case JOY_AXIS_FWD:   deadzone = joy_forward_deadzone.value; break;
+	case JOY_AXIS_SIDE:  deadzone = joy_side_deadzone.value; break;
+	case JOY_AXIS_PITCH: deadzone = joy_pitch_deadzone.value; break;
+	case JOY_AXIS_YAW:   deadzone = joy_yaw_deadzone.value; break;
+	default:
+		Con_Reportf( S_ERROR  "Joy_ProcessStick: invalid axis = %i", engineAxis );
+		break;
+	}
+
+	if( value < deadzone && value > -deadzone )
+		value = 0; // caught new event in deadzone, fill it with zero(no motion)
+
+	// update axis values
+	joyaxis[engineAxis].prevval = joyaxis[engineAxis].val;
+	joyaxis[engineAxis].val = value;
+
+	// fwd/side axis simulate hat movement
+	if( ( engineAxis == JOY_AXIS_SIDE || engineAxis == JOY_AXIS_FWD ) &&
+		( CL_IsInMenu() || CL_IsInConsole() ) )
+	{
+		int val = 0;
+
+		val |= Joy_GetHatValueForAxis( JOY_AXIS_SIDE );
+		val |= Joy_GetHatValueForAxis( JOY_AXIS_FWD );
+
+		Joy_HatMotionEvent( 0, val );
+	}
+}
+
+/*
+=============
+Joy_AxisMotionEvent
+
+Axis events
+=============
+*/
+void Joy_AxisMotionEvent( byte axis, short value )
+{
+	if( !joy_found.value )
+		return;
+
+	if( axis >= MAX_AXES )
+	{
+		Con_Reportf( "Only 6 axes is supported\n" );
+		return;
+	}
+
+	Joy_KnownAxisMotionEvent( joyaxesmap[axis], value );
+}
+
+void Joy_KnownAxisMotionEvent( engineAxis_t engineAxis, short value )
+{
+	if( engineAxis == JOY_AXIS_NULL )
+		return;
+
+	if( value == joyaxis[engineAxis].val )
+		return; // it is not an update
+
+	if( engineAxis >= JOY_AXIS_RT )
+		Joy_ProcessTrigger( engineAxis, value );
+	else
+		Joy_ProcessStick( engineAxis, value );
+}
+
+/*
+=============
+Joy_BallMotionEvent
+
+Trackball events. UNDONE
+=============
+*/
+void Joy_BallMotionEvent( byte ball, short xrel, short yrel )
+{
+	//if( !joy_found.value )
+	//	return;
+}
+
+/*
+=============
+Joy_ButtonEvent
+
+Button events
+=============
+*/
+void Joy_ButtonEvent( byte button, byte down )
+{
+	if( !joy_found.value )
+		return;
+
+	// generic game button code.
+	if( button > 32 )
+	{
+		int origbutton = button;
+		button = ( button & 31 ) + K_AUX1;
+
+		Con_Reportf( "Only 32 joybuttons is supported, converting %i button ID to %s\n", origbutton, Key_KeynumToString( button ) );
+	}
+	else button += K_AUX1;
+
+	Key_Event( button, down );
+}
+
+/*
+=============
+Joy_RemoveEvent
+
+Called when joystick is removed. For future expansion
+=============
+*/
+void Joy_RemoveEvent( void )
+{
+	if( joy_found.value )
+		Cvar_FullSet( "joy_found", "0", FCVAR_READ_ONLY );
+}
+
+/*
+=============
+Joy_RemoveEvent
+
+Called when joystick is removed. For future expansion
+=============
+*/
+void Joy_AddEvent( void )
+{
+	if( joy_enable.value && !joy_found.value )
+		Cvar_FullSet( "joy_found", "1", FCVAR_READ_ONLY );
+}
+
+/*
+=============
+Joy_FinalizeMove
+
+Append movement from axis. Called everyframe
+=============
+*/
+void Joy_FinalizeMove( float *fw, float *side, float *dpitch, float *dyaw )
+{
+	if( !Joy_IsActive() )
+		return;
+
+	if( FBitSet( joy_axis_binding.flags, FCVAR_CHANGED ) )
+	{
+		const char *bind = joy_axis_binding.string;
+		size_t i;
+
+		for( i = 0; bind[i]; i++ )
+		{
+			switch( bind[i] )
+			{
+			case 's': joyaxesmap[i] = JOY_AXIS_SIDE; break;
+			case 'f': joyaxesmap[i] = JOY_AXIS_FWD; break;
+			case 'y': joyaxesmap[i] = JOY_AXIS_YAW; break;
+			case 'p': joyaxesmap[i] = JOY_AXIS_PITCH; break;
+			case 'r': joyaxesmap[i] = JOY_AXIS_RT; break;
+			case 'l': joyaxesmap[i] = JOY_AXIS_LT; break;
+			default : joyaxesmap[i] = JOY_AXIS_NULL; break;
+			}
+		}
+
+		ClearBits( joy_axis_binding.flags, FCVAR_CHANGED );
+	}
+
+	*fw     -= joy_forward.value * (float)joyaxis[JOY_AXIS_FWD ].val/(float)SHRT_MAX;  // must be form -1.0 to 1.0
+	*side   += joy_side.value    * (float)joyaxis[JOY_AXIS_SIDE].val/(float)SHRT_MAX;
+#if !defined(XASH_SDL)
+	*dpitch += joy_pitch.value * (float)joyaxis[JOY_AXIS_PITCH].val/(float)SHRT_MAX * host.realframetime;  // abs axis rotate is frametime related
+	*dyaw   -= joy_yaw.value   * (float)joyaxis[JOY_AXIS_YAW  ].val/(float)SHRT_MAX * host.realframetime;
+#else
+	// HACKHACK: SDL have inverted look axis.
+	*dpitch -= joy_pitch.value * (float)joyaxis[JOY_AXIS_PITCH].val/(float)SHRT_MAX * host.realframetime;
+	*dyaw   += joy_yaw.value   * (float)joyaxis[JOY_AXIS_YAW  ].val/(float)SHRT_MAX * host.realframetime;
+#endif
+}
+
+/*
+=============
+Joy_Init
+
+Main init procedure
+=============
+*/
+void Joy_Init( void )
+{
+	Cvar_RegisterVariable( &joy_pitch );
+	Cvar_RegisterVariable( &joy_yaw );
+	Cvar_RegisterVariable( &joy_side );
+	Cvar_RegisterVariable( &joy_forward );
+
+	Cvar_RegisterVariable( &joy_lt_threshold );
+	Cvar_RegisterVariable( &joy_rt_threshold );
+
+	// emit a key event at 75% axis move
+	Cvar_RegisterVariable( &joy_side_key_threshold );
+	Cvar_RegisterVariable( &joy_forward_key_threshold );
+
+	// by default, we rely on deadzone detection come from system, but some glitchy devices report false deadzones
+	Cvar_RegisterVariable( &joy_side_deadzone );
+	Cvar_RegisterVariable( &joy_forward_deadzone );
+	Cvar_RegisterVariable( &joy_pitch_deadzone );
+	Cvar_RegisterVariable( &joy_yaw_deadzone );
+
+	Cvar_RegisterVariable( &joy_axis_binding );
+	Cvar_RegisterVariable( &joy_found );
+	// we doesn't loaded config.cfg yet, so this cvar is not archive.
+	// change by +set joy_index in cmdline
+	Cvar_RegisterVariable( &joy_index );
+
+	Cvar_RegisterVariable( &joy_enable );
+
+	// renamed from -nojoy to -noenginejoy to not conflict with
+	// client.dll's joystick support
+	if( Sys_CheckParm( "-noenginejoy" ))
+	{
+		Cvar_FullSet( "joy_enable", "0", FCVAR_READ_ONLY );
+		return;
+	}
+
+	Cvar_FullSet( "joy_found", va( "%d", Platform_JoyInit( joy_index.value )), FCVAR_READ_ONLY );
+
+	joy_initialized = true;
+}
+
+/*
+===========
+Joy_Shutdown
+
+Shutdown joystick code
+===========
+*/
+void Joy_Shutdown( void )
+{
+	if( joy_initialized )
+	{
+		Cvar_FullSet( "joy_found", 0, FCVAR_READ_ONLY );
+	}
+}

engine/client/input.c

@@ -0,0 +1,630 @@
+/*
+input.c - win32 input devices
+Copyright (C) 2007 Uncle Mike
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+*/
+
+#include "common.h"
+#include "input.h"
+#include "client.h"
+#include "vgui_draw.h"
+
+#if XASH_SDL
+#include <SDL.h>
+#endif
+
+#include "platform/platform.h"
+
+void*		in_mousecursor;
+qboolean	in_mouseactive;				// false when not focus app
+qboolean	in_mouseinitialized;
+qboolean	in_mouse_suspended;
+POINT		in_lastvalidpos;
+qboolean	in_mouse_savedpos;
+static int in_mstate = 0;
+static struct inputstate_s
+{
+	float lastpitch, lastyaw;
+} inputstate;
+
+CVAR_DEFINE_AUTO( m_pitch, "0.022", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "mouse pitch value" );
+CVAR_DEFINE_AUTO( m_yaw, "0.022", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "mouse yaw value" );
+CVAR_DEFINE_AUTO( m_ignore, DEFAULT_M_IGNORE, FCVAR_ARCHIVE | FCVAR_FILTERABLE, "ignore mouse events" );
+static CVAR_DEFINE_AUTO( look_filter, "0", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "filter look events making it smoother" );
+static CVAR_DEFINE_AUTO( m_rawinput, "1", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "enable mouse raw input" );
+
+static CVAR_DEFINE_AUTO( cl_forwardspeed, "400", FCVAR_ARCHIVE | FCVAR_CLIENTDLL | FCVAR_FILTERABLE, "Default forward move speed" );
+static CVAR_DEFINE_AUTO( cl_backspeed, "400", FCVAR_ARCHIVE | FCVAR_CLIENTDLL | FCVAR_FILTERABLE, "Default back move speed"  );
+static CVAR_DEFINE_AUTO( cl_sidespeed, "400", FCVAR_ARCHIVE | FCVAR_CLIENTDLL | FCVAR_FILTERABLE, "Default side move speed"  );
+
+/*
+================
+IN_CollectInputDevices
+
+Returns a bit mask representing connected devices or, at least, enabled
+================
+*/
+uint IN_CollectInputDevices( void )
+{
+	uint ret = 0;
+
+	if( !m_ignore.value ) // no way to check is mouse connected, so use cvar only
+		ret |= INPUT_DEVICE_MOUSE;
+
+	if( touch_enable.value )
+		ret |= INPUT_DEVICE_TOUCH;
+
+	if( Joy_IsActive() ) // connected or enabled
+		ret |= INPUT_DEVICE_JOYSTICK;
+
+	Con_Reportf( "Connected devices: %s%s%s%s\n",
+		FBitSet( ret, INPUT_DEVICE_MOUSE )    ? "mouse " : "",
+		FBitSet( ret, INPUT_DEVICE_TOUCH )    ? "touch " : "",
+		FBitSet( ret, INPUT_DEVICE_JOYSTICK ) ? "joy " : "",
+		FBitSet( ret, INPUT_DEVICE_VR )       ? "vr " : "");
+
+	return ret;
+}
+
+/*
+=================
+IN_LockInputDevices
+
+tries to lock any possibilty to connect another input device after
+player is connected to the server
+=================
+*/
+void IN_LockInputDevices( qboolean lock )
+{
+	extern convar_t joy_enable; // private to input system
+
+	if( lock )
+	{
+		SetBits( m_ignore.flags, FCVAR_READ_ONLY );
+		SetBits( joy_enable.flags, FCVAR_READ_ONLY );
+		SetBits( touch_enable.flags, FCVAR_READ_ONLY );
+	}
+	else
+	{
+		ClearBits( m_ignore.flags, FCVAR_READ_ONLY );
+		ClearBits( joy_enable.flags, FCVAR_READ_ONLY );
+		ClearBits( touch_enable.flags, FCVAR_READ_ONLY );
+	}
+}
+
+
+/*
+===========
+IN_StartupMouse
+===========
+*/
+void IN_StartupMouse( void )
+{
+	Cvar_RegisterVariable( &m_ignore );
+
+	Cvar_RegisterVariable( &m_pitch );
+	Cvar_RegisterVariable( &m_yaw );
+	Cvar_RegisterVariable( &look_filter );
+	Cvar_RegisterVariable( &m_rawinput );
+
+	// You can use -nomouse argument to prevent using mouse from client
+	// -noenginemouse will disable all mouse input
+	if( Sys_CheckParm(  "-noenginemouse" )) return;
+
+	in_mouseinitialized = true;
+}
+
+void GAME_EXPORT IN_SetCursor( void *hCursor )
+{
+	// stub
+}
+
+/*
+===========
+IN_MouseSavePos
+
+Save mouse pos before state change e.g. changelevel
+===========
+*/
+void IN_MouseSavePos( void )
+{
+	if( !in_mouseactive )
+		return;
+
+	Platform_GetMousePos( &in_lastvalidpos.x, &in_lastvalidpos.y );
+	in_mouse_savedpos = true;
+}
+
+/*
+===========
+IN_MouseRestorePos
+
+Restore right position for background
+===========
+*/
+void IN_MouseRestorePos( void )
+{
+	if( !in_mouse_savedpos )
+		return;
+
+	Platform_SetMousePos( in_lastvalidpos.x, in_lastvalidpos.y );
+
+	in_mouse_savedpos = false;
+}
+
+/*
+===========
+IN_ToggleClientMouse
+
+Called when key_dest is changed
+===========
+*/
+void IN_ToggleClientMouse( int newstate, int oldstate )
+{
+	if( newstate == oldstate )
+		return;
+
+	// since SetCursorType controls cursor visibility
+	// execute it first, and then check mouse grab state
+	if( newstate == key_menu || newstate == key_console )
+	{
+		Platform_SetCursorType( dc_arrow );
+
+#if XASH_USE_EVDEV
+		Evdev_SetGrab( false );
+#endif
+	}
+	else
+	{
+		Platform_SetCursorType( dc_none );
+
+#if XASH_USE_EVDEV
+		Evdev_SetGrab( true );
+#endif
+	}
+
+	// don't leave the user without cursor if they enabled m_ignore
+	if( m_ignore.value )
+		return;
+
+	if( oldstate == key_game )
+	{
+		IN_DeactivateMouse();
+	}
+	else if( newstate == key_game )
+	{
+		IN_ActivateMouse();
+	}
+}
+
+void IN_CheckMouseState( qboolean active )
+{
+	static qboolean s_bRawInput, s_bMouseGrab;
+
+#if XASH_WIN32
+	qboolean useRawInput = ( m_rawinput.value && clgame.client_dll_uses_sdl ) || clgame.dllFuncs.pfnLookEvent != NULL;
+#else
+	qboolean useRawInput = true; // always use SDL code
+#endif
+
+	if( m_ignore.value )
+		return;
+
+	if( active && useRawInput && !host.mouse_visible && cls.state == ca_active )
+	{
+		if( !s_bRawInput )
+		{
+#if XASH_SDL == 2
+			SDL_GetRelativeMouseState( NULL, NULL );
+			SDL_SetRelativeMouseMode( SDL_TRUE );
+#endif
+
+			// Con_Printf( "Enable relative mode\n" );
+			s_bRawInput = true;
+		}
+	}
+	else
+	{
+		if( s_bRawInput )
+		{
+#if XASH_SDL == 2
+			SDL_GetRelativeMouseState( NULL, NULL );
+			SDL_SetRelativeMouseMode( SDL_FALSE );
+#endif
+			// Con_Printf( "Disable relative mode\n" );
+			s_bRawInput = false;
+		}
+	}
+
+	if( active && !host.mouse_visible && cls.state == ca_active )
+	{
+		if( !s_bMouseGrab )
+		{
+#if XASH_SDL
+			SDL_SetWindowGrab( host.hWnd, SDL_TRUE );
+#endif
+			// Con_Printf( "Enable grab\n" );
+			s_bMouseGrab = true;
+		}
+	}
+	else
+	{
+		if( s_bMouseGrab )
+		{
+#if XASH_SDL
+			SDL_SetWindowGrab( host.hWnd, SDL_FALSE );
+#endif
+
+			// Con_Printf( "Disable grab\n" );
+			s_bMouseGrab = false;
+		}
+	}
+}
+
+/*
+===========
+IN_ActivateMouse
+
+Called when the window gains focus or changes in some way
+===========
+*/
+void IN_ActivateMouse( void )
+{
+	if( !in_mouseinitialized )
+		return;
+
+	IN_CheckMouseState( true );
+	if( clgame.dllFuncs.IN_ActivateMouse )
+		clgame.dllFuncs.IN_ActivateMouse();
+	in_mouseactive = true;
+}
+
+/*
+===========
+IN_DeactivateMouse
+
+Called when the window loses focus
+===========
+*/
+void IN_DeactivateMouse( void )
+{
+	if( !in_mouseinitialized )
+		return;
+
+	IN_CheckMouseState( false );
+	if( clgame.dllFuncs.IN_DeactivateMouse )
+		clgame.dllFuncs.IN_DeactivateMouse();
+	in_mouseactive = false;
+}
+
+
+
+/*
+================
+IN_MouseMove
+================
+*/
+void IN_MouseMove( void )
+{
+	int x, y;
+
+	if( !in_mouseinitialized )
+		return;
+
+	if( touch_emulate.value )
+	{
+		// touch emulation overrides all input
+		Touch_KeyEvent( 0, 0 );
+		return;
+	}
+
+	// find mouse movement
+	Platform_GetMousePos( &x, &y );
+
+	VGui_MouseMove( x, y );
+
+	// if the menu is visible, move the menu cursor
+	UI_MouseMove( x, y );
+}
+
+/*
+===========
+IN_MouseEvent
+===========
+*/
+void IN_MouseEvent( int key, int down )
+{
+	if( !in_mouseinitialized )
+		return;
+
+	if( down )
+		SetBits( in_mstate, BIT( key ));
+	else ClearBits( in_mstate, BIT( key ));
+
+	// touch emulation overrides all input
+	if( touch_emulate.value )
+	{
+		Touch_KeyEvent( K_MOUSE1 + key, down );
+	}
+	else if( cls.key_dest == key_game )
+	{
+		// perform button actions
+		VGui_MouseEvent( K_MOUSE1 + key, down );
+
+		// don't do Key_Event here
+		// client may override IN_MouseEvent
+		// but by default it calls back to Key_Event anyway
+		if( in_mouseactive )
+			clgame.dllFuncs.IN_MouseEvent( in_mstate );
+	}
+	else
+	{
+		// perform button actions
+		Key_Event( K_MOUSE1 + key, down );
+	}
+}
+
+/*
+==============
+IN_MWheelEvent
+
+direction is negative for wheel down, otherwise wheel up
+==============
+*/
+void IN_MWheelEvent( int y )
+{
+	int b = y > 0 ? K_MWHEELUP : K_MWHEELDOWN;
+
+	VGui_MWheelEvent( y );
+
+	Key_Event( b, true );
+	Key_Event( b, false );
+}
+
+/*
+===========
+IN_Shutdown
+===========
+*/
+void IN_Shutdown( void )
+{
+	IN_DeactivateMouse( );
+
+#if XASH_USE_EVDEV
+	Evdev_Shutdown();
+#endif
+
+	Touch_Shutdown();
+}
+
+
+/*
+===========
+IN_Init
+===========
+*/
+void IN_Init( void )
+{
+	Cvar_RegisterVariable( &cl_forwardspeed );
+	Cvar_RegisterVariable( &cl_backspeed );
+	Cvar_RegisterVariable( &cl_sidespeed );
+
+	if( !Host_IsDedicated() )
+	{
+		IN_StartupMouse( );
+
+		Joy_Init(); // common joystick support init
+
+		Touch_Init();
+
+#if XASH_USE_EVDEV
+		Evdev_Init();
+#endif
+	}
+}
+
+/*
+================
+IN_JoyMove
+
+Common function for engine joystick movement
+
+	-1 < forwardmove < 1,	-1 < sidemove < 1
+
+================
+*/
+
+#define F (1U << 0)	// Forward
+#define B (1U << 1)	// Back
+#define L (1U << 2)	// Left
+#define R (1U << 3)	// Right
+#define T (1U << 4)	// Forward stop
+#define S (1U << 5)	// Side stop
+static void IN_JoyAppendMove( usercmd_t *cmd, float forwardmove, float sidemove )
+{
+	static uint moveflags = T | S;
+
+	if( forwardmove ) cmd->forwardmove  = forwardmove * cl_forwardspeed.value;
+	if( sidemove ) cmd->sidemove  = sidemove * cl_sidespeed.value;
+
+	if( forwardmove )
+	{
+		moveflags &= ~T;
+	}
+	else if( !( moveflags & T ) )
+	{
+		Cmd_ExecuteString( "-back" );
+		Cmd_ExecuteString( "-forward" );
+		moveflags |= T;
+	}
+
+	if( sidemove )
+	{
+		moveflags &= ~S;
+	}
+	else if( !( moveflags & S ) )
+	{
+		Cmd_ExecuteString( "-moveleft" );
+		Cmd_ExecuteString( "-moveright" );
+		moveflags |= S;
+	}
+
+	if ( forwardmove > 0.7f && !( moveflags & F ))
+	{
+		moveflags |= F;
+		Cmd_ExecuteString( "+forward" );
+	}
+	else if ( forwardmove < 0.7f && ( moveflags & F ))
+	{
+		moveflags &= ~F;
+		Cmd_ExecuteString( "-forward" );
+	}
+
+	if ( forwardmove < -0.7f && !( moveflags & B ))
+	{
+		moveflags |= B;
+		Cmd_ExecuteString( "+back" );
+	}
+	else if ( forwardmove > -0.7f && ( moveflags & B ))
+	{
+		moveflags &= ~B;
+		Cmd_ExecuteString( "-back" );
+	}
+
+	if ( sidemove > 0.9f && !( moveflags & R ))
+	{
+		moveflags |= R;
+		Cmd_ExecuteString( "+moveright" );
+	}
+	else if ( sidemove < 0.9f && ( moveflags & R ))
+	{
+		moveflags &= ~R;
+		Cmd_ExecuteString( "-moveright" );
+	}
+
+	if ( sidemove < -0.9f && !( moveflags & L ))
+	{
+		moveflags |= L;
+		Cmd_ExecuteString( "+moveleft" );
+	}
+	else if ( sidemove > -0.9f && ( moveflags & L ))
+	{
+		moveflags &= ~L;
+		Cmd_ExecuteString( "-moveleft" );
+	}
+}
+
+static void IN_CollectInput( float *forward, float *side, float *pitch, float *yaw, qboolean includeMouse )
+{
+	if( includeMouse )
+	{
+		float x, y;
+		Platform_MouseMove( &x, &y );
+		*pitch += y * m_pitch.value;
+		*yaw   -= x * m_yaw.value;
+
+#if XASH_USE_EVDEV
+		IN_EvdevMove( yaw, pitch );
+#endif
+	}
+
+	Joy_FinalizeMove( forward, side, yaw, pitch );
+	Touch_GetMove( forward, side, yaw, pitch );
+
+	if( look_filter.value )
+	{
+		*pitch = ( inputstate.lastpitch + *pitch ) / 2;
+		*yaw   = ( inputstate.lastyaw   + *yaw ) / 2;
+		inputstate.lastpitch = *pitch;
+		inputstate.lastyaw   = *yaw;
+	}
+
+}
+
+/*
+================
+IN_EngineAppendMove
+
+Called from cl_main.c after generating command in client
+================
+*/
+void IN_EngineAppendMove( float frametime, void *cmd1, qboolean active )
+{
+	float forward, side, pitch, yaw;
+	usercmd_t *cmd = cmd1;
+
+	if( clgame.dllFuncs.pfnLookEvent )
+		return;
+
+	if( cls.key_dest != key_game || cl.paused || cl.intermission )
+		return;
+
+	forward = side = pitch = yaw = 0;
+
+	if( active )
+	{
+		float sensitivity = 1;//( (float)cl.local.scr_fov / (float)90.0f );
+
+		IN_CollectInput( &forward, &side, &pitch, &yaw, false );
+
+		IN_JoyAppendMove( cmd, forward, side );
+
+		if( pitch || yaw )
+		{
+			cmd->viewangles[YAW]   += yaw * sensitivity;
+			cmd->viewangles[PITCH] += pitch * sensitivity;
+			cmd->viewangles[PITCH] = bound( -90, cmd->viewangles[PITCH], 90 );
+			VectorCopy( cmd->viewangles, cl.viewangles );
+		}
+	}
+}
+
+void IN_Commands( void )
+{
+#if XASH_USE_EVDEV
+	IN_EvdevFrame();
+#endif
+
+	if( clgame.dllFuncs.pfnLookEvent )
+	{
+		float forward = 0, side = 0, pitch = 0, yaw = 0;
+
+		IN_CollectInput( &forward, &side, &pitch, &yaw, in_mouseinitialized && !m_ignore.value );
+
+		if( cls.key_dest == key_game )
+		{
+			clgame.dllFuncs.pfnLookEvent( yaw, pitch );
+			clgame.dllFuncs.pfnMoveEvent( forward, side );
+		}
+	}
+
+	if( !in_mouseinitialized )
+		return;
+
+	IN_CheckMouseState( in_mouseactive );
+}
+
+/*
+==================
+Host_InputFrame
+
+Called every frame, even if not generating commands
+==================
+*/
+void Host_InputFrame( void )
+{
+	Sys_SendKeyEvents ();
+
+	IN_Commands();
+
+	IN_MouseMove();
+}