license: err, lets go with gnu GPLv2. too lazy to pick one right now. this is from-scratch code, however I have more than a passing familiarity with quake's source.


this started out as an attempt to draw an entire quake worldmodel in a single draw call, hence the name.
however, in order for this to work fully, you need a maxwell+ nvidia gpu with bindless textures.

it implements a few different aproaches to throwing geometry at the screen.
the default mode is not a single draw call, but rather a single multidrawindirect call. this was required to get bindless textures working on amd gpus (which require dynamically uniform samplers, thus necessitating multidraws or instancing).


the 'opengl' version does NOT use bindless textures and thus cannot use a single draw call for the entire world, not even a single multidraw. this version instead attempts to abuse texture arrays, but still requires 1 draw call per texture size. only the ati-friendly path is supported, as I'm too lazy to do all sorts of sorting for each alternative (and makes the worst cases even worse).
as a result it is not interesting as a comparison between world traversal strategys (because it only implements one). however, it does tend to get slightly higher framerates.


model rendering is a nice addition and is not part of the one-draw-call ideal, however it does attempt to use batching where it can.
this results in it throwing up to 512 entities at the screen per multidrawindirect call, each one animating individually with its own model and crazy stuff like that.
bindless vs opengl does not affect the draw calls themselves. the bindless version uses naturally sized npot textures, while the non-bindless version uses a single texture array in a way that is kinda wasteful in terms of memory.


commandline arguments:
-game FOO: loads the foo gamedir, just like quake
+map FOO: loads up the named map in a sort of map-viewer mode.
+connect FOO: connects to the named NQ server.. Note that '+connect demo:demo1.dem' initiates playback of the named demo.
-basedir FOO: specifies your quake directory (where the exes normally are).
By default, it'll start playing demo1.dem.
Note that on completion of a demo, the engine will say how many video frames it generated, and thus the average framerate. Note that this does not match quake's habit of playing demos insanely fast so they're over before you realised that they'd started.


bugs:
interpolation is present, but kinda fucked. expect glitches and judders due to this.
inline models are not currently supported. there are texturing issues there.
the vulkan renderer is shit.
there's currently no way to make it fullscreen. this means that bufferswaps require copies to the screen rather than simple buffer swaps. this can affect the framerate a bit when you're gpu-limited.


The vulkan version is my learning exercise with the vulkan API. vulkan does not support bindless textures, this the implementation is limited similarly to the generic opengl version.
It has simplified shaders, so water+sky will display wrongly.
It lacks any mdl support, as I've not gotten around to it yet.
It doesn't support mipmapping, as I'm too lazy to figure out how to generate mips efficiently.
For some reason, ammo boxes etc are invisible.
I think I'm leaking commandbuffers.
Make up your own mind regarding framerates.
the bsp rendering logic is very similar to the default pvsonly-multi rendering mode.