Readme

dgVoodoo 2.83.2: Glide and DirectX API libraries implemented on D3D11/12
Released: Oct 06, 2024
Author: Dege

Hardware rendering at GPU feature level 12.0 (recommended but currently has some issues)
Hardware rendering at GPU feature level 11.0 (recommended)
Hardware rendering at GPU feature level 10.1 (has a minor limitation for DX8/9)
Hardware rendering at GPU feature level 10.0 (there are some limitations)
Software rendering through Microsoft WARP renderer

The following graphics API libraries are implemented:

Glide 2.11, Glide 2.45, Glide 3.1 and Glide 3.1 Napalm
DirectX 1-7 (all versions of DirectDraw and Direct3D up to version 7)
Direct3D 8.1
Direct3D 9

For both Glide and DirectX, dgVoodoo pushes as many emulation work to the GPU as possbile. Thus, the entire internal 3Dfx GPU logic is mapped to pixel shaders for Glide emulation, and all the fixed function vertex & pixel processing pipeline is implemented by shaders for DirectX emulation (when possible).

3. Requirements

Minimum:

Operating system: Windows Vista/7/8/10
Hardware: GPU supporting DirectX feature level 10.0.

Optional and recommended:

GPU supporting DirectX feature level 11.0 or higher

4. Test results

We can examine this in two aspects:

Used hardware and performance
I've tested and run different versions of dgVoodoo2 on the following GPU's:
- Intel HD 2000 (only with old drivers supporting feature level 10.1)
- GeForce 8600 GT (feature level 10.0 only)
- Intel HD 4000
- Geforce GT 610
- AMD HD 6450
- Intel HD Graphics 530
- GeForce GTS 450
- AMD HD 7850
- GeForce GTX Ti560 (RIP)
- AMD R7 360
- GeForce GTX 1060
Accuracy of the emulation, individual games and applications
Of course it's not perfect but I think I got very nice results in general. I maintain expanding lists for games and demos, for DirectX emulation:
Games
Demos

5. Usage

There is no installer for dgVoodoo beacuse you can copy its dlls anywhere you want (to use). If u like it and want to use as the only global Glide wrapper on your machine then copy Glide dlls to the system folder. Glide dlls are available in both 32bit (x86) and 64bit (x64) versions. x64 version is for 64 bit QEmu (and maybe 64 bit DosBox) builds. For native usage you always need the 32bit (x86) version dlls.
For DirectX emulation only a local installation is possible since the DirectX dlls CANNOT be copied to the system folder (see DirectX readme). Also, D3D9 has both 32 and 64 bit versions. Always use the proper one, depending on the application type (not the OS type).

A Glide wrapped application can start up either in windowed or full screen mode (it is controlled by the Control Panel, see later). Also, you can switch between them during the gameplay by Alt-Enter. See 'Known issues' for more.

The same is true for wrapped DirectX applications, but it is a more complicated case, see DirectX readme.

Glide and DirectX dlls can co-work inside a process so the same versions of them have to be used within a folder. If one of them detects the other with different version then it refuses to initialize and work. Co-work is useful for applications that use DirectDraw for some initial in-game menu and Glide for 3D rendering.

6. Configuring

As different options might wanted to be used for particular applications, I kept the concept of local/global configurations (might be familiar from old dgVoodoo). Current configuration is stored in a file named 'dgVoodoo.conf'. Its format can either be binary or a textual INI-file for manual editing.

When the Glide or DirectX wrapped application starts, dgVoodoo tries to read config data. The search paths and the order for the config file are the following:

Folder of the wrapper DLL
Folder of the application (EXE)
User application data folder

If the config file can be found in none of them then the default config is used.

For modifying config files, you can either use dgVoodoo Control Panel (dgVoodooCpl) or edit it manually with a text editor. dgVoodooCPL provides convenient GUI interface for all options but only the most important sections are available by default. You have to enable the advanced options through the context menu. This is because of emphasizing the sufficiency of the default sections for the everyday usage and leaving the advanced sections for practiced users knowing what they are doing.
In dgVoodooCpl you can choose a folder where you can load (from) and save the current configuration. Once you chose a folder, it remains in the list permanently. If the CPL application finds a valid config file in its own folder (where the app itself is located) then it automatically places the folder into the list and selects the folder. Otherwise the user's application data folder is selected, by default.

Note that

CPL always writes INI format config file (unlike previous versions) - and you can edit it manually, passing over the CPL
CPL doesn't expose all the sections of the configuration by default only the most important ones - you have to enable additional ones through the context menu

If an application tolerates losing focus without closing/minimizing itself, you can configure it dynamically: when the CPL starts up it builds a list of detected running Glide/DirectX wrapped applications and insert it into the folder selector combobox. When you select such a running instance then the current state of the application is read as config and most of the options can also be changed. So, you can set resolution, msaa, brightness, etc on the spot without restarting the application (configurable items depend on emulation type). When an option changes, it takes effect at once. If the dialog gets cancelled or an other config folder/instance is selected, all the changes gets cancelled as well.

You can always use the 'Apply' button to save the current config to the selected folder or running application without exiting the CPL application. Important to note:

If the wrapped app and the CPL runs on different privilege levels (admin/nonadmin) then the app won't appear in the instance list or they cannot communicate to each other. Sorry for the inconvenience.
Switching resolution or MSAA can only be performed perfectly if the application re-renders everything on each frame. If it uses or keeps previously (once-)rendered things like cockpits or similars then they will be missing as will not get re-rendered. (Glide only)

A folder inserted formerly into the list can be removed. Also, list of the running instances can be refreshed.

7. Resolution and refresh rate overriding

You can override the application resolution and refresh rate both for Glide and DirectX rendering.
There are three types of resolution overriding, and, the 'Resolution' comboboxes contain two types of elements in the enumerated list:

Static resolutions

Those are enumerated by your videocard for the selected display output. Select any of them, and the wrapper will force that one (along with the selected refresh rate), no matter what resolution the application wants to set.
Resolution 'Unforced' means always using the current application resolution, so there is no overriding at all.
Dynamic resolutions

First, a little explanation on what the practical problems are with static resolutions (especially for DirectX applications).
- The application may use multiple resolutions for different parts like movies, menus and ingame. The statically chosen resolution may not have the same aspect ratio as those of them. For app-resolutions with different aspect ratios like 4:3 vs 16:9 it's a problem because one of them will be displayed hugely distorted.
- Even if the app uses only one resolution, and you can select or type another one with the same aspect ratio, then selecting the proper resolution is still not an easy task:
  a) you don't necessarily know what resolution the app uses
  b) you don't necessarily know what the max resolution your display is capable of
  c) even if you know both of them, you may have to calculate manually the desired resolution.
(My own problem was the following: I sat down in front of a new computer with a 4K monitor and wanted to try out some stuffs through dgVoodoo. I faced the fact that I didn't know the exact monitor resolution, I also didn't know what res the stuffs to try were using. I just wanted the maximum available resolution to be forced that keeps the aspect ratio.)

Dynamic resolution is the synonim of "let the wrapper choose the current resolution for you". The maximum, and also the base used for calculating the current resolution, is your desktop resolution. The base rule is that the wrapper always calculates the maximum available resolution for the given scaling mode, but
- you can restrict the base maximum to FullHD (1920x1080) or QHD (2560x1440) for weaker GPUs (like low-end cards or maybe, integrated chips) with large-res display outputs, and
- you can restrict the scale factor to integer numbers.
  (ISF - integer scale factor)
So, dynamic resolutions are the following:
- 2x, 3x, ...: Integer multiples of application resolutions; doubled, tripled, etc.
- Max: Maximum resolution available
- Max ISF: Maximum resolution with integer scale factor available
- Max FHD: Maximum resolution available (but restricted to 1920x1080)
- Max FHD ISF: Maximum resolution with integer scale factor available (but restricted to 1920x1080)
- Max QHD: Maximum resolution available (but restricted to 2560x1440)
- Max QHD ISF: Maximum resolution with integer scale factor available (but restricted to 2560x1440)
- Desktop: Desktop resolution (this value can be forced, see additional General options); this value simply overrides the application resolution so the aspect ratio is not necessarily preserved. This is useful for games patched to render at a widescreen camera FOV but support only old-style 4:3 or 5:4 resolutions.
All of them can have an additional integer scale parameter. The concrete resolution resulting from the calculations is multiplied by the scale. "Max 2x" and "Max ISF 2x" are predefined ones available in the CPL resolution list because they can be useful for manual supersampled rendering.

When working with a dynamic resolution, the concrete resolution is unknown (calculated at runtime) hence no refresh rates are enumerated along with them, even if enumerating refresh rates is enabled. You can still force one (see Custom resolutions below).
See the API specific readmes to understand the logic of selecting a real refresh rate value for unforced cases.
Custom resolutions

A custom resolution is either a static one that is not in the enumerated list, or one that is partially overridden. Defining a custom resolution through the CPL is about typing the string -manually into the combo box- describing the resolution/refresh rate pair.
Resolution and refresh rate can be overridden independently on each other. Here are some examples (don't type quotation marks):
- "128x128, 60" - means static resolution 128x128 at forced rate of 60Hz
- "128x128, 0" or just "128x128" - means static resolution 128x128 without overridden refresh rate
- "0x0, 75" or "unforced, 75" - means unforced (static) resolution with forced 75Hz
- "max_isf, 83" - means Max ISF dynamic resolution with forced 83Hz
- "max_qhd_2x, 60" - means twice of the Max QHD dynamic resolution with forced 60Hz
If your resolution and refresh rate is in the list then it is better to select it from there than typing it manually. It is because e.g. 60Hz is not exactly 60Hz in practice but 60.01Hz or 59.95Hz or so, depending on your display hardware. dgVoodoo always handles the refresh rates in their exact rational form but it cannot do that with manually typed ones.
When displaying a refresh rate in the combo box, dgVoodoo truncates the value. So, for example, 59.95Hz will appear as 59Hz in the list, while the display manufacturer probably claims that your display supports 60Hz. Don't let it mislead you. It is all about truncating or rounding the values.

If you are terribly interested in how the current dynamic resolution is calculated then a little technical part comes here. Otherwise you can skip this section.

D:	desktop resolution
F:	FullHD resolution (1920x1080)
Q:	QHD resolution (2560x1440)
A:	application resolution
AS (x, y):	stretched from x to y, with aspect ratio
IAS (x, y):	stretched from x to y, with aspect ratio, integer scale factor

	Unspecified	Centered	Stretched	Stretch with AR
Max	AS (A, D)	AS (A, D)	D	AS (A, D)
Max ISF	IAS (A, D)	IAS (A, D)	* remarks	IAS (A, D)
Max FHD	AS (A, min (D,F))	AS (A, min (D,F))	min (D,F)	AS (A, min (D,F))
Max FHD ISF	IAS (A, min (D,F))	IAS (A, min (D,F))	* remarks	IAS (A, min (D,F))
Max QHD	AS (A, min (D,Q))	AS (A, min (D,Q))	min (Q,F)	AS (A, min (D,Q))
Max QHD ISF	IAS (A, min (D,Q))	IAS (A, min (D,Q))	* remarks	IAS (A, min (D,Q))

Remarks:

Resolution is calculated in the same way for scaling mode 'Unspecified', 'Centered' and 'Stretch with AR'.
Stretched scaling mode with ISF tries to stretch to min([D|F|Q]) and the scale factor for both direction is the integer part of the minimum of
min ([Dx|Fx|Qx])/Ax and min ([Dy|Fy|Qy])/Ay (ratios of X/Y directions).

I'd like to say some words about what happens on multimonitor systems with dynamic resolution forcing:

Glide: when switching from windowed mode to fullscreen then a new forced resolution is calculated by the wrapper, based on the native res of the display on which the full screen output will appear.
DX: It's not so flexible at all, unfortunately. Since DX impl doesn't support changing resolution during its working, it cannot do the same as Glide when switching into fullscreen. Also, since display outputs are enumerated to the application, resolution calculation can rely only on the native res of the output on which DX is initialized (so changing the output of a running DX emulated app from the CPL application is without avail, won't affect the next resolution calculation).

What happens for a multihead case (D3D9), meaning an application is driving more than one display output simultaneously through one device where all allocated resources are shared between them?
Since the resolution scaling factor must be the same for all (one scaling factor per device), the forced resolution can not necessarily be the expected one for each output device. The factor is the proportion of the forced and the application resolution. If it is the same for all display outputs, like when it comes directly from the dynamic scaling mode (2x, 3x, ...) then there is no problem. If not then it is calculated for all display outputs one by one and the factor for the output with the highest forced resolution is used for all. It means that the actual forced resolution on the other outputs are adjusted by that factor and it will differ from the expected, even if a static resolution is forced in the config.
So, forcing resolution for a multihead case is not a good idea. Leave it unforced and configure the resolutions from the application.

8. General options

Options on the General tab affects all wrapped APIs, that is, currently Glide and DirectX.

Output API
- Direct3D12 feature level 12.0
- Direct3D12 feature level 11.0
- Direct3D11 feature level 11.0
- Direct3D11 feature level 10.1
- Direct3D11 feature level 10.0
- Direct3D11 Microsoft WARP renderer
D3D11 with FL10.1 has limitations and affects only D3D8/9:
- There is no support for N-patches
- Max texture size is 8K x 8K
D3D11 with FL10.0 is designed to be used with late DX 10.0 hardware and has more limitations:
- No mipmapping in Glide rendering
- Limited operations on Z-buffers
- There is no support for N-patches
- Buffers with forced MSAA can only be rendering targets; they cannot be used as
  - depth textures
  - source of copy operations (Blit in DDraw)
  - locked for CPU-access (Lock in DDraw/ LockRect in D3D8)
- Faces of 3D-rendered cube-depth buffers cannot be
  - source of copy operations (Blit in DDraw)
  - locked for CPU-access (Lock in DDraw/ LockRect in D3D8)
WARP is a software renderer and can be used as a reference driver.
Video card (adapter)
In case you have more than one, then
- Glide: which one to use for rendering. Option 'All of them' is equivalent to selecting the first video card in the list.
- DirectX: it is a multi-device capable API so you can choose which adapter(s) are to be enabled for the emulation.
Monitor (output)
If you have multiple monitors then you can choose which one(s) (connected to the selected adapter):
- Glide: which monitor is used for fullscreen output. When 'Default' is selected then switching from windowed to fullscreen during playing a game selects the monitor containing the largest part of the game window.
  It can be overridden dynamically on a running Glide wrapped application and it also affects dynamic resolution calculating (see resolution overriding).
- DirectX: which monitor(s) to enable to appear as DX devices to the application. 'Default' enables all the monitors connected to the selected adapter. When the game or application goes into fullscreen then it always happens on the monitor (device) that the game/application selected for use. In case of a multidevice environment games and applications often (and silently) selects the first available device which generally corresponds to the primary monitor, but advanced apps allows the user to configure it through the app itself.
  It can be overridden dynamically on a running DirectX-wrapped application however it only affects the output, it is all about pure visuality. It doesn't affects dynamic resolution calculating (see resolution overriding) and also, the application shall continue to see the corresponding device in it original state (keep in mind that it can conflict with the app).
Full Screen / Windowed
See section "Usage".
Unspecified/Centered/Scaled/Scaled with Aspect Ratio kept, for full screen
If the current resolution the wrapped app using does not match any natural resolution your adapter supports then the display can be strethed out to fit all the screen or its size can be left unchanged but centered. NOTE that if your video card supports overriding the scaling method of applications, and you'd like to apply a scaling with aspect ratio then it is recommended to set dgVoodoo's scaling method to 'Unspecified' + set the scaling mode on your video card control panel because dgVoodoo's internal scaling is unfortunately not a sterling one. It implies that you may experience various problems like wrong mouse cursor or glitches in rendering in certain applications. Scaling can only be done well (transparently) on the GPU/display side.
C64-like output: well, if you are not a former C64 owner and fan, don't even try it, I'm sure you won't like it at all. As dgVoodoo is my main hobby programming playground these times I tried some algorhytms as part of it. It's not really a feature, but the result of some former experimenting and can be funny for some scene demos.
Progressive scanline order
Default scanline order is interlaced or progressive. It is up to the output display device which one to choose altough it chooses progressive when it is possible, I think, so that when the device is capable of displaying a given resolution with a given refresh rate with progressive order. Otherwise it might choose interlaced order with halved physical refresh rate. If this option is enabled, you can only see enumerated resolutions that are displayable with progressive order. However, if a custom resolution is defined then it may causes the output device to use lower physical resolution than the wrapper set.
Enumerate refresh rates
Enables the CPL application to enumerate refresh rates for each resolution and enables the wrapper to override the default refresh rate of the application. However using other than the app default can cause heavy animation lagging or glitches!
Color adjustments
Brightness, color intensity (saturation) and contrast can be finetuned here. The defaults are good in general so treat this as a cool extra. (I'm using it in some cases for making colors more vital to get a bit cartoon-like effect.)
Inherit Color Profile in full screen mode
This option is only taken into account if D3D11 as output API is explicitly selected. The purpose of this is providing compatibility mode for old hardware with enabling true gamma calibration instead of a postprocess rendering step. Color profiles are always inherited otherwise meaning that color adjustments are relative to the predefined color profile in that case.
Keep window aspect ratio
In windowed mode, when sizing the window, you can keep the aspect ratio of the current resolution.
Capture mouse
It's useful mainly (but not only) for multimonitor systems. If this is enabled then the mouse cursor is forced into the application window to prevent accidental mis-clicks outside of it. In multimonitor or multihead cases the mouse is locked into the bounding rectangle of the affected display outputs (the ones that are driven by the application).
Center app window
When a game controlling the mouse input is being run in windowed mode then it's a pain to move it's window into the screen, so I thought it's a valuable option (was a request too), but it can conflict with the mouse input or the app itself.

9. General additional options

DesktopResolution

dgVoodoo takes the current desktop resolution as a base to do its calculations for self-done output scaling and other things like automatic pixel multiplying factor value. There some games however that pre-set the desktop resolution (typically to some low resolution) before dgVoodoo gets in action, spoiling the rendering. You can define your native desktop resolution here for such cases. If defined then this resolution is used for all outputs of the desktop.
DesktopBitDepth

You can define what screen bit depth should be reported through dgVoodoo. It can be 8, 16 or 32. Empty definition means the current system desktop bit depth.
DeframerSize

When resolution is forced to other than the app default then a black frame is drawn around the output image coming from a wrapped API to remove scaling artifacts - frame thickness can be defined in pixels (max 16, 0 = disable) (default is 1).
ImageScaleFactor

Integer factor for scaling the output image coming from a wrapped API (pixel multiplying). This is independent on scaling mode. 0 = maximum available factor. Default is 1 (no multiplying). Separate factors can be defined for horizontal and vertical directions.
CursorScaleFactor

Integer factor for scaling the emulated hardware cursor. It has effect only for scaling modes where the image processing is done by dgVoodoo itself. 0 = automatic, in this case the integer factor is calculated from the application resolution and the forced resolution. 1 = no scaling, 2 = double size, etc., max 16.
PresentationModel

Low-level swapchain swap effect: if you know what you are doing then it can be overridden here. Flip models are better suited for modern OS features like auto HDR, while plain legacy models provide the best presentation performance under ideal conditions.
Not all "model + output API + OS version" combinations are supported, "flip" models need Win10 at least and D3D12 only supports "flip" models. Possible values are
- Discard: DXGI discard (legacy BitBlt)
- Sequential: DXGI sequential (legacy BitBlt)
- Flip discard: DXGI Flip discard
- Flip sequential: DXGI Flip sequential
- Automatic: "Discard" for D3D11, "Flip discard" for D3D12
DisplayROI

Display region of interest: you can define a subrectangle in forced resolution space (or application resolution if it is unforced) to be the input of the scaling and image presenting process. It works only for scaling modes where the image processing is done by dgVoodoo itself. Subrectangle can either be
- defined as a proportion in form of %d_%d, like 16_9 or 16_10, etc.
- or defined as a pixel size in form of %d|%d, like 320|200 or 640|400, etc.
Pos subproperty defines the top-left position of the rectangle. It can be
- centered (default)
- a pixel position in form of %d|%d, like 100|100
Resampling

When the scaling is done by the wrapper for the given scaling mode, you can choose which type of resampling filter to use. Those are the following, in the order of complexity:
- Point sampled: the simplest and fastest but providing pixelated result
- Bilinear: Smooth but blurred result
- Lanczos-2: Smooth but more sharper result - it can produce slight halation around sharp edges
- Bicubic: Smooth but more sharper result
- Lanczos-3: Smooth and sharpest result - it can produce stronger halation than Lanczos-2
ColorSpace

Various SDR/HDR color spaces can be selected for the image (swapchain) output. It's experimental because 'WCG SDR' and 'HDR' needs a display device with the proper capabilities so I couldn't really test it all. Feedback are welcome. The internal DX rendering precision (or quality) is adjusted to the selected color space by default. For ARGB2101010 color spaces 16 bit precision is used by default so the lowered alpha bits should not be a problem.
- ARGB:8888: legacy 32 bit output
- ARGB:2101010: 32 bit output with extended precision
- ARGB:2101010 WCG: The same as the previous but according to MS it's targeted for "specially provisioned SDR displays" and the OS Advanced Color mode handles it (Win11)
- ARGB:16161616: true HDR output with float16 precision per component.
FreeMouse

When enabled, physical mouse is free to move inside the game window when using emulated scaling and/or application and forced resolution differs; can be useful when a game relies on the physical window size.
WindowedAttributes

You can force various properties for windowed mode rendering. The following properties can be listed, separated by commas
- Borderless: forces borderless window
- AlwaysOnTop: forces the window into the topmost z-order band
- FullscreenSize: the window content is the same as in fullscreen mode including the potential side black bars, depending on the scaling mode
You can more or less emulate fake fullscreen with defining Borderless and FullscreenSize together along with enabling centered window.
FullscreenAttributes

You can force properties for fullscreen mode rendering. The following properties can be listed, separated by commas
- Fake: forces fake fullscreen rendering with a screen sized borderless window. This is basically the same that you can achieve with borderless fullscreen size windowed mode rendering but with mouse emulation enabled.
FPSLimit

You can define an FPS value here to limit the rendering to. Limiting to range larger than ~400 FPS requires more CPU power than lower ranges because of the more precise timing intervals.
Environment

Defines the software environment in which dgVoodoo is running. Its value can be
- empty (default)
- DosBox: to force DosBox environment
- QEmu
Unless you use dgVoodoo in QEmu it's recommended to leave its value empty because dgVoodoo can detect DosBox automatically.
In QEmu environment dgVoodoo disables its own handling of the rendering window including Alt-Enter for manual screen mode switching.
SystemHookFlags

You can define separate flags separated by commans for hooking different parts of the system (x86-DirectX only). Flags are
- empty (default)
- GDI: to hook GDI-rendering (cutscene videos)
- Cursor: to hook mouse-cursor to suppress double cursor symptoms for emulated cursor

10. Direct3D 12

Why D3D12? Because I wanted to code something using D3D12 and rotating cubes are boring. However, it has some drawbacks in dgVoodoo compared to D3D11.
Here are some facts and tips in regard of D3D12:

dgVoodoo D3D11 can be broken with AMD GPU's (DirectX modules). I got a ton of reports complaining about solid colored polygons instead of textured ones. The cause of the problem is discovered, and it is a bug in certain AMD drivers that I couldn't detect and workaround automatically. On the other hand, according to the feedback I got, D3D12 works as expected so this is your best bet on AMD hardware. If you get crashes with D3D12 after all then try to disable the 'Radeon Anti-Lag' feature for your GPU. I got a user report where that helped (thanks for that!!).
Windows (not the OS but GUI windows) backed by swapchains with FLIP_DISCARD presenting mode, which is mandatory for D3D12, cannot transition back to "legacy" (GDI) presentation mode. Unfortunately it means that D3D12 can be completely unusable for applications that render into their windows through multiple API's like GDI, D3D9, etc. and D3D12 (dgVoodoo). Such an application is DosBox. I don't recommend dgVoodoo D3D12 for that, unless you play a Glide game that has no VGA-rendered parts.
Unlike D3D11 swapchains in dgVoodoo, D3D12 swapchains (FLIP_DISCARD) always render into a window, even in fullscreen mode. Some games resize their window to match the resolution they think they rendering at. No matter if you run the game in fullscreen mode, this causes a small window in the top-left corner of the desktop if it happens. Try disabling option 'Disable Alt-Enter to toggle screen state' (see DirectX options) in such a case. It may help because dgVoodoo window hooking runs on a different path in that case and it forces back the window size to cover the entire screen.
MSI Afterburner relies on D3D11on12 to render its own overlay when hooking D3D12. I ran into multiple cases when D3D11on12 crashed or hung at startup, for unknown reasons. First try a game with MSIA shut down if you have problem with launching it.
Because of the problems listed above and other known D3D12 issues that I want to address in subsequent releases, Output API option 'Best available' never chooses D3D12 automatically. If you want D3D12 then you must choose it explicitly in the config.
If you encounter crash(es) or defective rendering then try to patch the executable to 4GB-aware (32 bit D3D9 games hardly fitting into the 2GB address space)
A last one: unlike in D3D11, feature levels cannot be forced in D3D12. D3D12 takes the minimum feature level as an input parameter but initializes itself at the highest available one (which is greater than or equal to the mininum). So, if your GPU supports FL12.0 then it's all for the same which feature level you choose in the config.

11. ARM64/ARM64X builds

I tested them on my Surface Pro X with the native ARM64 build of DosBox-X.

D3D9 as DosBox output with Glide wrapping works (set the enviroment in dgVoodoo config to 'DosBox').

Qualcomm has only D3D11 and D3D12 drivers and there are minor glitches with them, and also, the compute shaders seem not to work properly (C-64 like output). I'll investigate them later because I don't know yet if they are purely driver bugs or a problem with my code coming from the lack of cache coherence which I should fix (the correspondent x64 build works as expected).

D3D9 is ARM64X build which is a fat binary containing native ARM64 code inside but the module type can either be native ARM64 or X64 depending on what type of process it is loaded into. In other words, you can use this DLL for both native ARM64 and emulated X64 applications without taking any care about the application type. The point is, if an application is 64 bit then you can universally use this DLL for that and it will run at maximum performance, natively.

ARM64 Glide DLL's are not fat binaries because the only 64 bit Glide application is DosBox x64 builds but DosBox-X has native ARM64 builds so Glide ARM64X makes no sense.

12. General tips and known issues

Forcing things (like resolution, antialiasing, texture filtering, etc) is not a healthy thing. If an application or game uses low resolution or point sampled textures or anything dissonant to the eye then it has reasons for that. It is not because the programmers were so lame but of avoiding artifacts that would otherwise get brought in (typical example is a bilinear filtered texture with colorkey based transparency). If you force anything then potentially get one of those artifacts. If you can live with it then it is ok, use the wrapper in forced mode. If not then disable all forcings and use the particular game or application in the mode it was designed for, because no general method exists to fix such type of artifacts.
Controlling antialiasing cannot be done on per-primitive basis in Direct3D 11 when feature set larger than 10.0 is used. That is why antialiased drawing is not emulated in Glide automatically in this version in any way (per-primitive or per-edge). It can only be forced globally in the CPL application.
You can disable option 'Inherit Color Profile in full screen mode' if D3D11 is explicitly selected as an output API. This is useful for old hardware to save some GPU power for the rendering.
When an application is being run in compatibility mode (Win98/XP etc) then the user's application data folder is different than the OS default. Therefore dgVoodoo cannot read the global config file and the default config gets applied if no local config file is present. The preferred way is creating a local config for such cases if other than the default needed. (Perhaps using the user's appdata folder is not a too good idea after all, I might change it later.)
If you have a multimonitor system then always try a game to run on the primary one for the first time. Some games lock the mouse cursor to the screen area where game window is assumed to be (the left-top corner of the desktop). If such a game is being forced onto another monitor then clicking in the game causes application focus loss because its window is not under the mouse cursor.
I don't know why but overriding refresh rates by arbitrary values (in the resolution selector combo box) does not seem to work for DirectX emulation. It is still subject to investigation because the code handling this is common for both Glide and DirectX. :(

13. Special release version with debug layer

Special release version of dgVoodoo contains an additional validator and report layer. Its purpose is

1) giving feedback to the user about potential error conditions, what currently is happening, and, how dgVoodoo is driven by the application at all
2) helping debugging a given application/game by the (extensive) feedback and opening the possibility to break into the debugger

dgVoodoo currently has 2 main types for debug feedback

Simple messages with 3 subtypes which can be disabled or associated with a debugger break

INFO: harmless message about various events like creating/releasing an API object, reading a config file, loading a module, etc.
WARNING: a message about a potential error condition
ERROR: a message about an API driving error or an internal error of dgVoodoo. The latter is fatal, while the prior one may be normal.

Tracing - means the full logging of API calls made to dgVoodoo and some additional information of dgVoodoo internals.

Level 0: Tracing disabled
Level 1: Logging of API calls
Level 2: Logging of API calls + some additional info

Messages and tracing are independent on each other. Tracing is mainly for devs, for quick and average usage only the messages are recommended.
All of them are written to the debug output, logging to file is not yet implemented.

So, I recommend you to use DebugView or much more DebugView++. They are very cool applications for cases when no any debugger is available. Also, if you have more than one monitors then you can watch the log in realtime: put DebugView++ on one display and run the game on another.

Messages have a '[dgVoodoo]' prefix so the best way to check out a game with dgVoodoo's debug layer is enabling filtering to the 'dgVoodoo' substring (Crtl-L in DebugView and F5 in DebugView++). Every single log output appear in new lines in DebugView/DebugView++ - this is nice, except for some tracing messages written to the output part by part, like D3D8 disassembled shaders. Unfortunately they appear nastily because of that.

It's not really a big problem however because I cannot recommend you to enable tracing. It's much more intended for developers but if you want to use it after all then do it with DebugView++ or a debugger like Visual Studio 2015 because feedback is so tremendous that only tools with asynchronous debug output window are able to handle it. Tools with synchronous debug output like DebugView won't be able to keep up with it and make your game/app crawl at speed near zero.

I must emphasize:

Do not look for a miracle when using the debug layer! If some game doesn't work for you then it can give you some useful feedback on what's going on, or you can see if dgVoodoo is utilized at all but won't necessarily tell you why the game crashes, for example.
Also, if you see an ERROR entry in the log then it doesn't necessarily mean you did something wrong or there is a problem with your game. Many games rely on error codes got back from an API. So, for example if you see such a log like the following snippet
```
...
[15500] [dgVoodoo] INFO: Direct3DDevice (0D3967D8)::EnumTextureFormats: Format XRGB8888 is enumerated to the application.
[15500] [dgVoodoo] INFO: Direct3DDevice (0D3967D8)::EnumTextureFormats: Format ARGB8888 is enumerated to the application.
[15500] [dgVoodoo] INFO: Direct3DDevice (0D3967D8) is released.
[15500] [dgVoodoo] ERROR: DirectDrawSurface (0D2380C8)::DeleteAttachedSurface: Failed, HRESULT: DDERR_SURFACENOTATTACHED
[15500] [dgVoodoo] INFO: DirectDrawSurface (0D2380C8) Plain offscreen rendertarget is released.
[15500] [dgVoodoo] INFO: Direct3D (0ABC87B0)::EnumDevices: Device enumerated, Name: "Direct3D HAL", Description: "dgVoodoo Hardware A...
...
```
Then the error entry about failed 'DeleteAttachedSurface' is not really an error. The application tried to delete a potential attached z-buffer, just to make sure, and doesn't care about the result. dgVoodoo however treat it as an error because it caused an error in an API method. It's really impossible to make a decision about classifying some conditions as an error or just a plain warning.
But let's look at another case: one of my game just crashes right at startup. What could be the reason? The debug output is:
```
...
[21964] [dgVoodoo] INFO: Direct3D8 (077BCEC8) Virtual video card is 'dgVoodoo Virtual 3D Accelerated' with 64MB onboard memory.
[21964] [dgVoodoo] ERROR: Direct3D8 (077BCEC8): Validation of D3D8 swapchain presentation parameters failed.
                          Reason: display mode "800x600, 72Hz" is required but not supported by output device: 0, DeviceType: D3DDEVT...
[21964] [dgVoodoo] ERROR: Direct3DDevice8 (0EE99530)::Init: Cannot create device implicit swapchain.
[21964] [dgVoodoo] ERROR: Direct3D8 (077BCEC8)::CreateDevice: Initializing Direct3DDevice8 (0EE99530) failed.
...
```
Ah, OK. Previously I configured the game to run on a display at 72Hz but now I'm trying to run it on another that does not support this refresh rate at this resolution, so D3D8 initialization failed in dgVoodoo and so the game crashed due to lack of error checking.
Use the spec release only for trying to solve an extant problem with an applicaiton. Spec release does some extra checking and validation compared to normal dgVoodoo releases and it can bite off from the speed or cause stuttering.

14. Change log

2.83.2

Fixing a bug in the D3D12 backend (Radeon's Ark)
Fixing a swapchain creation crash (Lands of Lore 2)
Fixing a lighting bug with D3D execute buffers (Lego Island)
Fixing D3D mono rendering (Croc 2, ...)

2.83.1

Improving the D3D9 fixed function vertex pipeline to have full vertex-type input capability (CPU/GPU) (The Incredibles)
DDraw fixes related to YUV support
- Crash in the D3D12 backend (Populous The Beginning intro movie)
- Star Trek - Starfleet Academy movie playback
Fixing a DDraw clipper problem (O2 Jam)
Improving the DD/D3D debug layer leakage report to include orphan objects of released main objects

2.83

Frontend
- DD/D3D/8/9 objects consumes less memory and system resources
- Adding bounds checking into generated VS cpu code
- Improving API locking mechanism to avoid 'window message deadlock'
  dgVoodoo won't get into deadlock anymore with its own code in multithreaded window-message situations. However there are games (like TR4) that wait for DD/D3D without pumping the message queue, still causing deadlock/livelock. It cannot be resolved at wrapper side.
- Minor refactorings here and there
- Shared surface memory (Lock/GetDC) in DDraw and D3D9 where possible (better performance)
- Workarounding an invalid shader in D3D9 (WALL-E, Ratatouille, Up)
- Some changes in the capability of the GF9800 virtual card
DDraw
- Refactoring a lot of code to implement resource sharing to be compatible with MS DDraw (e.g. flashing screen in Colin McRae Rally 2)
- Implementing a shortcoming in DD compression Blt (Europe 1400)
- Implementing DD surface duplicating
- Adding some new dbg layer error messages into DD Blt'ing
- More compatibility with MS DDraw
- YUV format support
D3D
- Implementing some missing validation in D3D Draw methods
- Fixing minor debug layer bugs
- Fixing a D3D7 vertex clipping incompatibility (Torte Le Magic)
- Fixing a D3D8/9 resource binding bug
- Fixing a thing in D3D execute buffers (shadow in Final Racing)
D3D11/12 backend
- Adding a new option DirectXExt\D3D12BoundsChecking (try it if you run into a GPU crash with D3D8/9)
- Fixing a surface readback bug (Virtua Fighter 2 with forced resolution)
- Fixing some problems related to PS2/3 input registers declared as centroid (Insane 2 with ingame MSAA)
- Fixing a PS3 code generation problem (Borderlands with depth of field enabled)
- Fixing a regression bug in the blitter (Ephinea PSOBB, my own tests)
- Fixing a potential D3D12 deadlock problem (604)
- Adding a new addon callback to the API for creating custom D3D12 swapchains
- Fixing a 3D rendering bug in the D3D11/12 backends (SC Chaos Theory Versus Mode)
- Enabling flag DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING for FLIP presentation type swapchains if supported (windowed mode, fake fullscreen)
- Improving the synchronization of GPU/CPU access of poorly used D3D8/9 static buffers
- Fixing a regression bug in the blitter (Grand Prix 3 rearview mirrors)

2.82.5

Fixing a bug in the ps.3.0 shader code translator (FFXIII crash)
Fixing a bug in the D3D12 backend related to compressed textures (FFXIII Lightning Returns crash)
Fixing a DX frontend bug causing missing cutscenes (Ascension to the Throne)

2.82.4

Fixing DDraw bugs (Konami Collector's Series: Castlevania & Contra, Blackstone Chronicles)
Workarounding a DDraw internal resource sharing problem
Fixing DDraw clipped cursor problem (like with the config app of game Driver)
Fixing D3D5 vertex clipping (regression) (Jet Moto)
Removing paletted texture format support of the GF9800 virtual card
Fixing a potential D3D8/9 swapchain leaking bug
Fixing a D3D9 frontend bug (The Mark)
Fixing stenciling without a stencil plane in the D3D12 DX backend (Test Drive Unlimited 2)
Fixing potential descriptor corruption with sRGB textures in the D3D12 DX backend (Test Drive Unlimited 2)
Some minor refactoring in the DX frontent/backends
Fixing a clip coordinate space bug with sst origin lower left in Glide3+

2.82.3

D3D12 changes
- Fixing a caching bug in the 2D D3D12 backend causing black screen (La Mulana)
- Fixing an optimization bug in the 2D D3D12 backend causing crash (scene demo Platipus)
- Minimum stack size for the D3D12 background threads (Call of Duty 2) (but increase the stack reserve size of the exe instead)
- Some internal D3D12 improvements
- Workaroundig a resource state transition bug in D3D12 NV drivers (GF 10xx series?) (Glide/DX)
Common backend
- Various changes and minor optimizations in the code generators
- Fixing a bug in the FF ps code generator (Terrorist Takedown)
- Fixing a DDraw backend bug (Wing Commander 3)
General D3D
- Fixing the lighting incompatibility with MS D3D8/9 (my own tests)
- Fixing a regression bug in lighting (Splinter Cell: Chaos Theory Versus Mode)
D3D8
- Workarounding a ChromeEngine specific hack in D3D8 (Chrome, Chrome Specforce fog)
- Fixing a thing in D3D8 (Lord Of The Ring - Fellowship of The Ring)
D3D9
- Improving the implementation of D3D9 queries in the D3D12 backend to get far better response time (performance)
- Fixing a D3D9 bug (Arcania - Gothic 4)
- Fixing a bug and a leak in the D3D9 frontend
- Minor fixes in the D3D9 debug layer
Glide
- Changing the version number of Glide2 to 2.60 (Heretic II 3Dfx renderer)
- Some new error messages in the Glide debug layer for DllMain operations
- Optimizing Glide Draw calls with small amount of vertex/index data in the D3D12 backend for performance
- Fixing an lfb-writeback thing in Glide (Mech Warrior 2)
Control Panel App
- Increasing the vertical size a bit
- A fix for a resizing bug during DPI changes

2.82.2

Refactoring the FF ps code generator to produce a bit more optimal code
Fixing a lighting D3D incompatibility with MS D3D (Project I.G.I.)
Fixing a broken shader for D3D11 FL11.0 (Blood 2)
Adding Green Sardine/Cezanne AMD architectures to the D3D11 blacklist (device ID: 0x1638)
Fixing a bug in the blt shader code generator (Morrowind)

2.82.1

Remapped D3D/8/9 lights to reduce the number of FF shader variants (UT2004, RavenShield, games using FF vertex pipeline)
Fixing the 2D blitter and 3D texturer to handle colorkeyed ARGB2101010 and ARGB16161616 format textures properly
Compiler toolset upgrade

2.82

D3D/8/9 improvements and fixes
- Hardware vertex buffers in D3D6/7
- Improving the PS shader code generator to handle D3D colorkeyed textures (also fixing the D3D12 LOD-problem)
- Overhauling the general pipeline code and the capabilities of the FF pipeline
- Adding support for the reference device in D3D8/9 (Operation Blockade)
- Improved DD/D3D API tracing, some bugfixes/changes and additions in the DX debug layer
- Clipping / vertex layout / fog bugfixes (Extreme Paintbrawl 4, Max Payne, Off Road Arena)
- D3D9 fixes (fr-054 Polar, Crush, Nitro Stunt Racing, Trackmania Sunrise Extreme)
- Fixing the "clipped cursor" issue when exiting D3D8/9
- Improving DDraw compatibility (Legion Gold)
- Improving DirectShow compatibility (Project Eden)
- Forcing texture filtering did not work properly in D3D, fixed
- Fixing a regression bug in DDraw compression Blt (Eurofighter Typhoon)
- Fixing a windowed Blt bug in DDraw (my own test app)
- Fixing a regression crash in D3D12 UP Draw (Tomb Raider 5)
- A bugfix in the cpu code generator
- A bugfix in the blitter shader code generator
- Auto mipmap-generation (changing option DirectX\DisableMipmapping to DirectX\Mipmapping)
Glide fixes
- Fixing a rendering incompatibility (Outlaws)
- Fixing a freeze/crash bug in Glide D3D12 dynamic resolution changing
General improvements
- Changing/fixing a lot of things in the source using a code analyzer
- Doubling the tooltip appearance time in the Cpl
- Implementing loader lock detection for all (missing) platforms (x64, arm64/ec)
- Internal changes and code refactoring under the hood

2.81.3

Some D3D12 fixes including a weird issue with NV drivers (Prince of Persia)
Some bugfixes in the CPL
Fixing a common cache bug affecting both D3D11 and D3D12 (Earth Defense Force Insect Armageddon)
Improving the performance of user ptr Draw-calls in the D3D12 backend for small amount of vertex/index data (D3D/D3D8/9)

2.81.2

Fixing a D3D12 cache bug (banded shadows in some games)
Some D3D12 bugfixes (in both Glide and DX)
Adding new AMD GPU architectures to the D3D11 blacklist (Renoir/RX4xx/RX5xx series)
Fixing a deadlock when QuickTime player is active (regressive bug) (Septerra Core)
Modifying some code handling vertex data to get better performance on new CPU architectures (Sacrifice stress test)
Fixing a minor bug in the CPU code generator

2.81.1

Fixing a regression bug that can break DirectShow movie playback
Fixing another regression bug causing crash

2.81

A refactored 2D blitter architecture with a shader code generator for lower GPU-usage
- Comes in handy with integrated GPU's
A bugfix in the x86/64 VS CPU code generator
Fixing the AMD D3D11 solid-color-texture bug on certain GPU architectures (Vega as of now)
- D3D11 runs on an unoptimal but working path with those GPU's
- You can suppress it by enabling option DirectXExt\SuppressAMDBlacklist to check out if a new driver release fixes it
Experimental output color spaces are added for HDR/SDR WCG rendering
- Option GeneralExt\ColorSpace to choose between SDR/HDR outputs (Precision of the internal DX rendering is adjusted to the colorspace by default)
- Option DirectXExt\Default3DRenderFormat is modified to only control the internal rendering quality - you can override the default associated with the current colorspace
DDraw/D3D fixes:
- Implementing a flip-chain incompatibility with MS DDraw (Seven Kingdoms II HD)
- Implementing a missing optimization for 8 bit surfaces (Colin McRae Rally)
- Wrong rendering with forced resolution in certain cases
- Fixing palette update on integrated GPU's in the D3D12 backend (Colin McRae Rally)
D3D9 changes:
- Generating more optimal vs/ps shaders for D3D9 along with some performance improvement, in certain cases
Fixing broken clipping planes with D3D11 FL11.0 output (Tomb Raider Underworld)
Fixing D3D12 leaks
A lot of internal changes in the backends

2.8.2

Fixing D3D8/9 update-texture again (regressive bug) (Ys Seven, Valley Benchmark, ...)
Support for D3D12 triangle fans if the OS runtime and your driver supports it (Win11)
- This removes some software overhead in D3D8/9 Draw calls in certain cases
- There is a new dbg layer message for what D3D12 optional features are available and used
A bug is fixed in the D3D9 FVF validator (Lord of the Rings - War in the North, missing foliage)
Fractional viewports instead of shader code for D3D11 FL11.0+ (Test Drive Unlimited 2 through D3D11)
Fixing a bug in the CPU code generator and the default vs executor (Matrox Parhelia Reef demo)
Refactoring DDI blitting code (optimization, dev-only feature)

2.8.1

Fixing fogging for DX8.0 (Soul Reaver 2)
Fixing a bug in window handling (Silent Hill 3)
Fixing a bug in the CPU code generator
Changing compiler options for DX modules
A minor DX optimization

2.8

Glide fixes
- Glide lfb-access bug (Mech Warrior 2: 31st Century Combat)
- A Glide vertex shader (Nascar Racing 1999 Edition)
- A D3D12 Glide backend bug (Nascar Racing 1999 Edition)
- A D3D12 pixel shader crash
DDraw fixes
- Improving handling child windows (Twisted Insurrection)
- Surface factoring/handling incompatibilities (Tropico 1, Steel Beasts)
D3D fixes
- A caching bug (regression) (Lego Island)
- D3D fog state bug (Shadow Company)
D3D8/9 fixes
- Changing D3D9 sm2/3 ps behavior for mismatching sampler/texture type (FEAR)
- D3D8 fog incompatibilities (Enclave, Final Fantasy XI)
- sm3 fog problem in D3D9 (Lost - Via Domus)
- Windowed mode presentation (UnrealEd)
- Memory leak (The Legend of Heroes - Trails in the Sky 3rd)
- Texture update incompatibility + some improvement for the debug layer (Gray Matter)
- Memory allocation incompatibility for cube textures (Lost Planet 2)
- Frontend stateblock bug (Tiger Woods PGA Tour 2002)
- Device cursor functionality (Deus Ex - Invisible War)
- A D3D9Ex incompatibility (VPinballX)
- Workaround for a kind of memory overwrite from the application side (Lord of the Rings - War in the North)
- Adding a missing resource type/format combination as supported (Lord of the Rings - War in the North)
Software vertex processing
- Fixing an x64 D3D9 bug + some other common ones
- CPU code generator for D3D8/9 sw vertex processing (x86/x64 for the time being)
Backend fixes
- A D3D11 bug (Dawn of War 2 Retribution)
- A D3D12 bug causing deadlock (Test Drive Ferrari Racing Legend)
- A common bug (Test Drive Ferrari Racing Legend)
- Implementing a workaround for a D3D11 limitation (Test Drive Ferrari Racing Legend - car reflection)
Minor shader code generator bugs fixed (Rhino Discharge)
Fixing a mouse handling bug (regression) (Outlast windowed mode)
Fixing other internal bugs I encountered
Changes/refactorings related to the updated compiler tools
Changing option DirectX\BilinearBlitStretch to DirectX\Bilinear2DOperations
- So the filter is not only applied to 2D DD blit operations but CPU-written data as well
Changing option GeneralExt\EnableGDIHandling to GeneralExt\SystemHookFlags (x86-DX only)
- Flag 'GDI' to hook GDI-rendering (cutscene videos)
- Flag 'Cursor' to hook mouse-cursor to suppress double cursor symptoms for emulated cursor
ARM64X version of D3D9 instead of plain ARM64 native only
Implementing the first version of loading and driving dgVoodoo addons
- You can hook the image presentation of the D3D12 backend
- Docs and sample addon is added into the dgVoodoo API

2.79.3

Fixing D3D8/9 problems
- Vertex fog incompatibility (Ephinea PSOBB)
- Device reset bug (Harry Potter and the Order of the Phoenix)
- Fixing the return values of Check* methods (3DMark 05)
Changes in the D3D8/9 Debug Layer, some more detailed messages and cosmetics
Minor changes in the D3D12 D3D backend
Fixing a DDraw blitter bug (I hope at least) (driver crash with Lego Rock Raiders)
Fixing a bug in system (GDI) hooking (DX modules cooperating)
Fixing a certain D3D bug (Midtown Madness 1)
Fixing a DD/D3D colorkeying bug (Xarlor)
Other minor internal fixes and changes

2.79.2

Fixing a DDraw surface GetDC/ReleaseDC bug (Recoil, missing text)
Fixing D3D clipping again (Grand Prix 3)
Fixing a DDraw blitting colorkeying bug (Wizards and Warriors)
Changing scaling of cpu-written surface data from bilinear to point sampled
Fixing a D3D6 incompatibility with MS D3D (Lego Rock Raiders)
Fixing a bug in D3DImm (could crash at exit) (Crimson Skies)
Fixing a regression bug of swapchains (MS Flight Simulator 2002)
Fixing a bug of D3D8/9 fog state (MS Flight Simulator 2004)
Fixing a bug in sw vertexprocessing (wrong speculars in 3D Scooter Racing)

2.79.1

Broken D3D8/9 clipping, refactored and fixed (BloodRayne 2 HUD)
Fixing a D3D8/9 vertex layout bug (Sonic and All Stars Racing Transformed)
Minor other internal D3D5/6/7/8/9 fixes (like fr-063)
Minor D3D performance optimization
Improving Phong shading to support D3D8/9 level ops (LotR War of the Ring), but it's still not recommended
Shader code generator changes:
- fixing a bug (Star Wars Republic Commando)
- implementing missing mono rendering
A new Debug Layer message

2.79

Support for multihead (multimonitor) D3D9 devices (Supreme Commander)
Fixing/implementing DDraw/D3D9 cooperation for DirectShow movie playback (Robots)
D3D9 frontend fixes (Painkiller Black with D3D12)
D3D9 refresh rate validation improvement (Robots)
Adding option DirectXExt\DisplayOutputEnableMask for enabling individual display outputs
Adding option GeneralExt\PresentationModel (for "flip" presentation modes for D3D11)
Removing option DirectXExt\EnableSpecializedShaders
Fixing a regressive crash (Morbus Gravis)
Minor general improvements/optimizations and internal bugfixes (Outlast x64 and others)
Fixing Glide 1.x LFB-lock handling (Mech Warrior 2), but it seems to work only for me (feedbacks are welcome)
Removing DF16/DF24 depthstencil format support from GeForce virtual cards + fixing DF16/24/INTZ component mapping
Changing the behavior of clipping transformed/untransformed vertices
Fixing an incompatibility of updating the clip status in D3D

2.78.2

D3D12 threading fix for potential stuttering (Juiced)
A D3D12 fix for potential D3D9-query freeze (Prince of Persia: The Forgotten Sands)
A fix in the TruForm shader code generator (crash in Rainbow Six 3 Ravenshield)
A minor improvement for hw cursor emulation (Interstate '76)
Compiler toolset upgrade

2.78.1

A D3D8/9 incompatibility is fixed (RE - Operation Raccoon City)
A minor frame presentation optimization again (D3D11/12)
Fixing a Glide Debug Layer message (unnecessary d3dcompiler)
Slight changes in the FF vs DXBC generator for the sake of old FL10.0 drivers
Minor fixes in the D3D11 backend for FL10.0
A minor change in DXGI swapchain handling to reduce possibility of deadlocks (Blade Of Darkness)
Minor internal + CPL fixes
DDraw fixes
- Clip handling (Ed Hunter)
- Flip to GDI surface (HyperBlade)
- Changes to be compatible with the Windows compat layer (Biko)
- Other minor fixes (multi monitor tests)
- Improving the DirectShow (Quartz) hook layer (Max Payne)
Implementing more system/GDI hooks (option GeneralExt\EnableGDIHooking) (x86 only)
- HyperBlade menu
- Fixing double mouse cursors (experimental)

2.78

D3D8/9 fixes
- Implementing D3D9 API extensions for alpha-to-coverage and supersampling (nvidia/ATI)
- Supersampling needs at least FL10.1
- A bug in software buffer usage is fixed for software vertex processing (Everquest 1999)
D3D fixes
- Removing support for colorkey blending with GF virtual cards (Interact Play)
- Fixing a D3D alpha transparency bug (Interact Play)
Glide fixes:
- Fixing minor bugs in handling Glide LFB access (without PCI emulation) (XA demo)
- Fixing background threaded D3D12 Glide LFB access with PCI emulation (XA demo)
Image presentation changes
- DX frame presentation optimization for performance
- Other general optimization of presentation shaders
- Emulated cursor appeared at wrong place with integer scaling, fixed
Fixes for AMD
- A workaround-fix for clearing integer format RTV's through AMD D3D11 drivers (ClearRenderTargetView) (issue introduced with v2.74)
- Adapting the DX shader code generator to handle AMD's DXBC parser limitation (no-sat on indexed temporary) (crash with TruForm, HD7850)
Backend fixes
- A DX Draw bug fixed in the D3D12 backend
- Fixing a D3D11 sampler cache and sampler update bug (BF 1942, scene demo 604)
- Fixing a D3D12 sampler table update bug
- Fixing a bug in the DX code generator (crash with adaptive TruForm, HD7850)
- Changes for generating a bit more optimized code in FF vs code generator
Fixing a DDraw blitter bug (Des Blood 4)
Now all dynamic resolutions can have an integer scaling parameter, it can be useful for achieving manual supersampled rendering
Improving GDI hooking (MCI video player) (Age Of Empires 2)
Some new Debug Layer messages

2.77

D3D8/9 fixings
- Fixing an incompatibility of creating additional swapchains (Overlord 2)
- Implementing missing MSAA subpixel masking
- Implementing missing centroid modifier for ps2/3 input registers
- Fixing a bug in user ptr Draw-calls (Halo 2)
- Some new debug layer messages
Adding virtual card Geforce 9800 GT to have one that is still D3D9.0c compatible but more practical because does not support all features like the default internal one (Overlord2, Raiden 3, ...)
Fixing Glide3+ bugs (SurRender3D engine with Glide3)
Fixing a DDraw blitter bug (Esk Emotion)

2.76.1

Fixing bugs causing crash in the FF vs / TruForm shader code generator
Fixing D3D8/9 texture create-parameter validation (X-Blades)
Fixing a D3D12 swapchain bug (Balls of Steel through D3D12)
Fixing an inconsistency bug of the virtual cards other than the default (The Phantom Menace init error)
Improving the D3D/D3D8 z-biasing implementation (The Phantom Menace)

2.76

Adaptive N-Patch tesselation (ATI TruForm) support for D3D8/9 (needs feature level 11.0 through the output API as a minimum)
A new shader code generator for the D3D FF vertex pipeline in favor of better performance with specialized shaders
Enabling mixed MSAA types of D3D9 render- and depthstencil targets (some scene demos)
Bugfixes
- Fixing a DDraw surface create parameter validation incompatibility (Rogue Spear Urban Operations)
- Fixing x64 D3D9 stateblock handling crash
- Fixing a particular D3D8 lighting effect compatibility (Blitzkrieg map editor)
- Fixing a bug in the ps.3.0 DXBC generator
- Fixing a minor bug in DDraw with fast videomemory access
- Fixing freezing video playback in Mega Man X series
New options
- Adding scaling mode 'Stretched, keep aspect ratio (CRT like)'
- Adding DirectX\KeepFilterIfPointSampled
- Adding DirectXExt\NPatchTesselationLevel (only for experimenting purposes)
- Adding DirectXExt\EnableSpecializedShaders - this is intented to be a transitioning option, to be removed in a later version
Minor peformance optimization for handling ps FF specialized shaders
A lot of changes under the hood in general

2.75.1

Improving the implementation of user clip planes in the DX backends
Minor performance optimization in the D3D11 DX backend
Fixing potential D3D12 cache overflow
Fixing an incompatibility of GetDC/ReleaseDC on DDraw surfaces (The Secrects of Atlantis)
Fixing a regression bug with GetDC/ReleaseDC on DDraw surfaces (Star Wars Galactic Battlegrounds)
Fixing scaling of point sprites for upscaled resolutions (Falling Down)
Changing the precision of certain visibility calcs to be more compatible with MS D3D (Alien Paranoia)
Other minor code changes

2.75

Minor D3D incompatibility fixed (Corn N64 emulator)
Adding dynamic type resolution 'Desktop' (see the appropriate section for details)
Changing the implementation of D3D8/9 software cursor to be compatible with MS implementation
A bug in the general hw cursor emulation is fixed (No One Lives Forever)
Adding ARM64 builds of the 64 bit libraries and the CPL
Fixing a bug in the shader code generator (Virtua Tennis 4)
Minor DDraw compatibility fix (Alien vs Predator 2 corrupted health texture)
DDraw optimizations for LithTech engine lightmap textures handling (Alien vs Predator 2, but it should affect other games as well)
Improved GDI hooking to support the old MCI AVI player (Nocturne)
DDraw/D3D compatibility fixes to support the old ramp device (Banzai Bug) (As for the rendering, this game now runs fine with dgVoodoo in hw mode. However, still there is a problem, see this bug entry )
Some performance optimizations in the D3D11/12 DX backends
Fixing (refactoring) an old optimization for managed textures (Spirit of Speed 1937, missing textures)
Fractional (rational) values for option GeneralExt\FPSLimit
Fixing D3D8 depth sampling that's not compatible with D3D9 - this bug was introduced in 2.73 (Splinter Cell 2)

2.74.1

Reworking of the FPS limiter to avoid a possible input lag with D3D12
Fixing a D3D bug causing unreleased resources (SWAT 3, first run without a config file)
Change in the impl of the emulated hw cursor (SWAT 3 bad preformance, but affects other games too)
Fixing a bug in the new Glide DXBC generator (Scorched Planet demo)
Some optimization on DDrawSurface GetDC/ReleaseDC
Fixing vsync flag validation/interpretation in DDrawSurface::Flip
Minor change in certain DDraw Debug Layer messages
Minor fixes in the CPL

2.74

Enabling 16K sized surfaces in DDraw (Demon World 2)
Optimizing filling-type GPU-work all along the code for lower GPU usage (DDraw/D3D/presentation)
- This also involves some improvements in filling capabilities of DDraw
Removing an old general limitation related to swapchains + code refactoring
Implementing an FPS-limiter configurable through the new option GeneralExt\FPSLimit
Fixing bicubic + Lanczos filters combined with CRT-like appearance and integer scaling
Adding a new option GeneralExt\CursorScaleFactor to control the integer scaled appearance of the emulated hw cursor
Adding option DirectXExt\Default3DRenderFormat for possible higher dynamic range
Fixing a vs.1.x shader translator bug (The History Channel - Civil War)
Fixing a regressive D3D12 DX backend bug
Fixing a D3D12 common backend cache bug (nVidia Chameleon demo)
Fixing a bug with forced MSAA in D3D11/12 DX backends
Implementing missing point-type fillmode (nVidia tech demos)
Implementing some missing things in DDraw (Near Fantasy Space)
Minor change in handling the FPU state (Tantra Online)
A Glide3 incompatibility is fixed (Test Drive 5)
Glide x64 bugfixings: bad thick-line drawing and crash in guDrawPolygonVertexListWithClip
Slight modification in Glide window handling when enviroment is configured to Dosbox

2.73

Replacing the HLSL compiler in Glide ps shaders with an own code generator
So now dgVoodoo does not need the external D3DCompiler at all
Optimizations in D3D sw vertex processing calcs
Optimizations in D3D state blocks + some minor D3D9 optimizations
Fixing a D3D9 shader incompatibility (Mass Effect)
Fixing a shader validator bug (Garfield - Lasagna World Tour)
Fixing a regression bug in D3D frontend (Crush)
Fixing another bug in D3D frontend
Fixing a D3D12 API driving bug
Fixing a bump mapping bug in FF shaders (Matrox G400 demo)
Fixing a cube texture resolution scaling bug (Colin McRae Rally 3)
Fixing a vs.1.x code generator bug (Splinter Cell 2)
Fixing D3D9 vs.3.x pointsize output (Fable 3)
Minor comparison sampling fix for D3D8/9 (Test Drive Unlimited 2) (D3D12 is recommended)
Fixing a D3D colorkeying bug (Restricted Area)
Changing the criterions for accepting incoming refresh rate values in DX (see the DirectX readme for details)
Fixing a bug in Glide D3D12 backend (Ultimate Race Pro)
Fixing an encountered Glide bug (texture chroma range)
Minor modification for Glide GrSstWinOpen to accept (and convert) more invalid buffercount combinations
Some debug layer fixings for Glide3 Napalm
Gamma ramps now automatically works with D3D12 (with underlying optimizations)
- Color profile is always inherited because of calibration standards on modern systems
- Option General\InheritColorProfileInFullScreenMode is only taken into account when a D3D11 output API is explicitly selected (compatibility mode for old hw)
Introducing option GeneralExt\FullscreenAttributes with attribute 'Fake' to enable fake fullscreen rendering
Enabling control tabbing + fixing tab-order for the CPL

2.72

Fixing a state management bug in the D3D11/12 backend (XIII)
Fixing a DDraw incompatibility bug (Tetris Worlds)
Fixing a Glide LFB locking bug + shutdown incompatibility (Speedboats, but this game has other problems too, causing crash)
Fixing a DDraw palette bug (Jedi Knight 2, ... and other old Star Wars games)
Fixing a bug in D3D9 frontend (Gothic 3)
Fixing an incompatibility in D3D8/9 frontend (Gothic 3)
Fixing some bugs in the D3D11 backend when revising code
Minor CPL improvements: adding 4GB to DX predefined videomemory values and observing textboxes to detect config changes
Internal changes/minor optimizations for future features

2.71.3

Fixing a bug in the DXBC generator (Metal Gear 2 Solid Substance, the original version)
Making DDraw device window creation compatible with MS DDraw (Everquest)
Minor improvement in the DDraw hook layer (Submarine Titans)
Fixing a bug in the shader code validator (Anarchy Online)
Implementing a minor missing thing in the D3D12 backend (Anarchy Online, but affects other appications as well)
Fixing a Glide texture upload bug (Montezuma's Return)
Fixing a thing incompatible with MS D3D (Christmas Magic)
Fixing a minor D3D12 leak

2.71.2

Fixing blurry output of upscaled DDraw rendering
Restoring old window handling behavior for D3D11 (Age Of Wonders, but affects other games too)
Minor Glide debug layer improvement for nonstandard resolution/refresh rate parameters

2.71.1

A regression bug in DDraw causing crash is fixed

2.71 - some modifications that should have been included in 2.7

Support for true multimon DDraw applications (my test app)
Minor performance improvements in D3D frontend and D3D12 backend (most noticable with Dreamfall The Longest Journey with D3D12)
Fixing a memory leak (my own tests)
Some minor refactoring in the code
Fixing a DDraw bug causing crash (Will Rock)

2.7

D3D12 backend (output API) for all modules
Various bugs are fixed in the D3D11 backend and common swapchain handling (also, it is refactored)
Various bugs are fixed both in Glide and DirectX frontend, including cooperating between Glide and DirectX
Improved fast video memory access with some fixes (DirectX)
2D DirectX operations are now more compatible with forced MSAA
Removing support for d3dcompiler_43 (affects only Glide)

2.64 - Incremental update to 2.63.2

Bug causing crash is fixed in D3D (Hot Wheel Micro Racers)
Fixing a bug in the DXBC generator (Psychonauts)
Fixing a bug in the DX11 backend causing corrupted textures (RIM - Battle Planets low texture quality)
Fixing a bug in D3D9 frontend (Hydro Thunder MAT3 crash)
Fixing an old limitation in dgVoodoo internals (crash with Atomic FE)
Dithering did not work with Glide3 Napalm build - fixed
Fixing malfunctioning auto-aspect ratio correction for swapchains unexpectedly forced back to windowed mode
Fixing broken dynamic resolution/MSAA/output config change in Glide

2.63.2 - Minor update to 2.63.1

DDraw palette fixes (unsupported types, crash) (Anarchy Online, Dark Omen)
Fixing DDraw texture/offscreen parameter validation (regression bug) (Planet Of The Apes)
Fixing DDraw texture restore bug (Machines)
Autogen-mipmap capability for the GF5700 virtual card (RPM Tuning)
Minor leak/crash fixings are ported back from the main branch

2.63.1 - Minor update to 2.63

Fixing DDraw texture parameter validation regression bug (Eurofighter Typhoon, Radeon's Ark, Zanzarah)
Fixing D3D device enumeration that was incompatible with MS D3D (Tomb Raider 4/5)
Minor improvement of D3D debug layer feedback
Improving internals of D3D resolution scaling (Omikron - The Nomad Sould pathed version, but affects other games too)
Fixing a minor D3D DXBC generator bug (Halo CE)
Fixing an annoying (regression) thing: desktop video mode can change for a short time when switching between fullscreen/windowed mode

2.63

New type of filters for resampling the output image are added (Bicubic, Lanczos-2, Lanczos-3)
Support for mipmapping when downscaling the output image
Default DirectX refresh rate is changed from 60Hz to the one coming from GeneralExt\DesktopResolution
DirectX-Glide cooperation bug, fixed (Hind)
Changing Glide texture filtering options
Minor bug in D3D9 sw lighting calcs, fixed
Cosmetic changes of some CPL tooltips

2.62.3 - Minor update to 2.62.2

Fixing minor D3D9 bugs (Splinter Cell 4)
Fixing D3D fogging bug (Pariah, but can easily affect other games)
Fixing minor DDraw incompatibilities (Dark Omen - but use it together with my game patch)
Disabling reporting 8 bit display modes as current monitor modes for D3D8/9 (Xanadu Next)

2.62.2 - Minor update to 2.62.1

Changing DDraw device GUIDs to match MS DDraw ones
Improving validation feedback for DDraw Create methods in debug layer
Optimizing something (60 Seconds for Mr. Light)
Fixing FVF validation for DX5/6/7 (Motocross Madness 2)
Fixing validation of vertexbuffer create parameters for DX6/7 (Hot Wheel Slot Cars)
Fixing minor buffering bug (Shadow Grounds)
Minor change in resolution scaling calcs
Fixing drawing of emulated monochrome cursors (Jane's FA-18)
Changing versioning of Glide modules (TA Kingdoms Glide3 renderer)
Changing hardware descriptor string for QEmu environment (Voodoo4)
Fixing minor bugs in the CPL

2.62.1 - Minor update to 2.62

Minor DDraw palette-incompatibility fix (Steel Beasts)
Fixing a minor incompatibility for generated shader code (Richard Burns Rally)
Minor optimization for generated shader code (Jurassic Park: Operation Genesis)
Changing failed scissor rect validation from ERROR to WARNING in D3D9 (Grand Chase)

2.62 - Update to 2.61

Fixing bugs in the DXBC generator (Halo CE, Splinter Cell 1, The Sims 2)
Fixing a drawing bug causing polygon corruption (The Sims 2)
Adding DX feature level 11.0 as output API for 16K size textures (DX8/9)
True software vertex processing in Draw* methods in DX modules for special cases, when needed (Nosferatu)
(but it was a general long outstanding compatibility problem)
Some DDraw blit refactor + adding option DirectXExt\PrimarySurfaceBatchedUpdate for batched update for primary surface changes
Some DDraw improvement for GDI interaction (Bad Mojo Redux video playback)
Size of the emulated hw cursor is now scaled according to the forced resolution and integer scale factors
Fixing the behavior of the emulated cursor when no any draw-changes made on the app side
Fixing bugs in handling rendering windows (Requiem)
Now all sections of the configuration are accessible through the CPL GUI (Ext sections are hidden by default though)
Adding a new option for, and implementing Display ROI (region of interest)
Now a subrectangle can be defined for scaling modes done by the wrapper. Useful for applications rendering into a widescreen subrectangle inside a 4:3 resolution - the widescreen subrectangle can be defined as display ROI, the input of the scaling process
Dithering didn't work for render targets with format A2R10G10B10, fixed

2.61 - Update to 2.6

Support for the external compiler in DirectX modules is removed, along with option DirectXExt\ShaderCodeGenerating
Bugfixes in the DXBC generator (Indiana Jones and The Emperor's Tomb, +general code revising)
Somewhat more optimized generated shader code + other minor optimizations
Minor DDraw fixes (Siege of Avalon)
Minor D3D vertex processing fix (Biko 1)
Adding option DirectExtX\MaxVSConstRegisters (Artifical Academy 2)
Fixing D3D9 scaling bugs (AvP Classic with DX9 renderer)

2.6

Support for Direct3D9
Internal shader code (DXBC) generator for DirectX libraries (the external compiler is no longer needed for them)
Various bugfixings, optimization and code refactoring for DirectX libraries
Some new config options
Fix for grTexCalcMemRequired for more compatibility with real drivers (Glide 1/2)
Fixing some polygon clipping issues (Glide 1/2)

2.55.4 - Update to 2.55.3

Adding new config element GeneralExt\WindowedAttributes for borderless and always on top windows
D3D6 fixes (The Sims, The Sims Complete Collection)
Changing default texture sample value (Silent Hill 2 'white shader')
DDraw fix (Lego Rock Raiders hangup)
D3D ProcessVertices fix (RIM - Battle Planets)

2.55.3 - Update to 2.55.2

Adding support for QEmu (x64 Glide binaries for Kjliew's Glide patch)
Fixing regression bug appearing in 2.55.1, related to adapter handling (causing crashes and other anomalies)
Adding value 'max' to option DirectXExt\ExtraEnumeratedResolutions
Adding new config element 'GeneralExt\Environment' for QEmu and DosBox
DDraw Blit colorfill fixed on 8bpp surfaces with forced resolution or MSAA (Colin McRae Rally)
DXGI swapchain fullscreen switch fix (Full Throttle, Sam & Max)
Simulating GF4 driver more precisely with the 'GF4 Ti 4800' video card type (Splinter Cell: Defense Ministry shadows)
Fix for special D3D8 behavior of vertex buffer locks (Lego Soccer Mania)
D3D8 pixel shader validator bug fixed (Mage Knight - Apocalypse)
Small fix in guTex* Glide function family (Turok demo)
Bug in mouse emulation is fixed (absorbing mouse input like in NFS - Porsche 2000)

2.55.2 - Minor update to 2.55.1

Bug when rendering with paletted textures, fixed (Final Fantasy 8 demo)
DirectDraw palette alpha-channel incompatibility, fixed (FFXI PlayOnline Viewer)
Texture upload crash, fixed (Redline demo)
Texture upload bug, fixed (Universal Monsters: Monsterville demo)
Clipping issues, fixed (Stratosphere)
Bug of config item GeneralExt\EnumeratedResolutionBitdepths is fixed

2.55.1 - Minor update to 2.55

Forceable internal bit depth of D3D depth buffers
Bugs in D3D light handling, fixed (Soldiers of Anarchy, Cold Zero demo)
D3D alphablending fix (Mage Bros)
Workaround for D3D8 vertex buffer overwrite (BattleField 1942)
Some incomplete interface querying is fixed for aggregated D3D devices
New options (enumerated resolution bit depths, limited default enumerated resolution) for DirectX along with minor fixes in the config validator
Corrected tmuRev and fbiRev version number for some 3Dfx card types
Minor changes in the debug layer (corrected mistypings, some value types are replaced by strings, etc.)

2.55

Special release of dgVoodoo with DebugLayer providing feedback information is now available
- INFO, WARNING and ERROR type messages with severity levels, including breaking into debugger
- API call tracing with detailed information
Migrating to INI format configuration files - also, adding rarely needed/used configuration options for advanced users and game hacking like
- Dithering for both Glide and DirectX
- Deframer
- Pixel multiplied output with arbitrary or automatic scale factor
- Arbitrary extra DirectX resolutions
New scaling mode for centered appearance, scaling is done by the wrapper
New dynamic resolution modes (2x, 3x, ...) are added
Fixes for scaled output done by the wrapper ('Stretched, * AR' and 'Centered, AR' modes with larger than max of display-supported output images)
Fix for 'Best available one' output type when only WARP is available
Improved shader handling:
- Resource cache for reuse of D3D8 compiled shaders
- Dynamic shader compiling is moved to a background thread to avoid/minimize lags
  Glide: for all compiled shaders
  DirectX: for all compiled shaders that can be substituted by precompiled ones; also, unneeded shader variants could be unnecessary compiled, fixed
Control Panel App
- Folder/location list handling code is rewritten
- Appearance is now PerMonitorAwareV2 for DPI scaling
- Cosmetics: missing logo bitmap when monitor scale is >150%, fixed
DirectX
- DllMain detection along with warning messages through the debug layer
- Surface/texture lock incompatibilites fixed (Zombie Shooter, The Mystery of the Druids)
- DirectDraw surface-create, cooperative level, PageLock error and other incompatibility fix (Zero Comico, RC de Go, A Bug's Life, Wartorn, Message in a Haunted Mansion, Micro Machines v3)
- 24 bit surface creation issue in DirectDraw is fixed (Blade Of Darkness lava)
- Support for partial Z-buffer copy in DirectDraw (The Revenant)
- Option for disabling the default and classic resolutions
- Possibility of extra resolutions enumerable to applications is added
- Bugs causing crash and black screen are fixed (Empires Dawn of The Modern World, Honour & Freedom)
- Some effort for avoiding app deadlocks in DirectDraw and QuartzHookLayer
- D3D FVF and other parameter validation incompatibility, fixed (Praetorians, Earthworm Jim 3D)
- D3D state block incompatibility, fixed (Soldiers of Anarchy)
- D3D non-W-friendly matrix in ComputeSphereVisibility calcs, fixed (Pac-Man Adventures in Time)
- Old D3D-lighting incompatibility, fixed (when revising code and docs)
- D3D lighting issue is fixed (flashing lights in Tomb Raider 4 and hopefully King Of The Roads)
- Fixing range based fog hw calculations (The Chosen: Well of Souls)
- ATI and GeForce profiles are modified to force W-pixelfog (compatibility with old drivers)
- Minor D3D DDI bug fixed (Bear Hero)
- Minor internal D3D state/lighting bugs fixed (Tonko4)
- D3D device type 'Software MMX' is removed from Direct3D7 for better compatibility (3D Blitz)
- Disabling 32 bit z-buffers for Direct3D3/5 (e.g. Shadows of The Empire)
- D3D FPU state handling incompatibility fix (for general cases, and it fixed nVidia demos Creature, Toy Soldiers and Crystal Ball)
- D3D colorkey bug fixed (Sponge Bob - Employee of The Month)
- Minor D3D/D3D8 bugs, D3D11 leaks fixed (my own tests)
- D3D/D3D8 ProcessVertices and general software vertex processing incompatibility, fixed (RIM - Battle Planets, Mafia with multipass rendering, Micro Commandos)
- Issue of mixed type D3D8 stream sources is fixed (missing player characters in Final Fantasy XI)
- D3D8 shader validator bug resulted in uncreated shaders, fixed (Mace Griffin Bounty Hunter)
- Implementing D3D8 ValidateVertexShader and ValidatePixelShader for Microsoft Shader Assembler (Shadow of Destiny)
- D3D8 cursor handling and viewport depth scaling bugs fixed (WildFire)
- D3D8 GetFrontBuffer bug, fixed (Rome Total War) (movies only, ingame still has the old issues)
- D3D8 device reset fix (S.W.I.N.E.)
- Some D3D8 thing is fixed (The Gladiators Demo)
- D3D8 some object handling incompatibility fix (TOCA Racing Drive)
- Improvements for rendering with incompatible rendertarget/depthstencil buffers (TOCA Racing Drive)
- Changed behavior of window activating and entering fullscreen mode to
  - Avoid OS issue appearing with Windows 10 Fall Creators Update (e.g. Splinter Cell)
  - Avoid unwanted situations/crashes and improve compatibility (e.g. Hitman 2/3, RavenShield)
Glide
- Clipping issues fixed (Gunmetal)
- LfbWriteRegion bug, fixed (Blade of Darkness, background images)
- Other fixes (broken multiadapter handling, manual screen mode changing)

2.54

Windows input issues caused by the wrapper are fixed (Outlaws, GTA1 DDraw mode, etc.)
Rendering transition between Glide/DDraw is fixed (Outlaws)
Concept of setup application is replaced with concept of Control Panel (CPL)
Control Panel App:
- Contrast as a new color adjustment option is added
- Preserving predefined monitor color profile(s) for fullscreen mode as an option is added
- A general option for centering the application/game window is added
- DirectX texture filtering options are changed, possibility of forcing anisotropic filtering is introduced
- New scaling mode with C64-like output (it's not a feature but more like an experimenting code)
- Visual cosmetics
DirectX:
- Some of the DDraw code is guarded to avoid the unexpected worst-way DLL unloading
  Now LithTech engine games (Blood2, NOLF, Kiss Psycho Circus, ...) should tolerate Alt-Tab on Win10
- Some other extra guarding to prevent crashes, Virtua Cop2 now works in D3D mode
- Blit bug and clipper incompatibility fixed in DDraw (D3DRM, Tokipazu, tech demo Final Reality)
- Minor issue in DDraw and bad L6V5U5 format descriptor is fixed (Kyro tech demos)
- Adding support for plain surface format A8L8 (DDraw) (Matrox G400 Tech Demo)
- D3D3 fog fixed (Shadows of The Empire patched to 1.1)
- Execute buffer bug fixed in D3D (D3DRM)
- Some D3D5 incompatibilities are fixed (crash and texture handling with Space Bunnies Must Die)
- Fixing D3D6 bugs and calculations of old software-only lighting and other incompatible things (DX6 SDK sample applications (Immediate/Retained) + Fog City/Tirtanium demos)
- Unexpected way of texture compression is implemented (D3D7, Soulbringer)
- Adding support for Q8W8V8U8 texture format (D3D8) (3DMark 2001 SE, Nature, Pixel shader and Advanced Pixel shader test)
- D3D8 device handling bug is fixed (multimonitor environment)
- D3D8 compatibility fixings, now handling managed textures is compatible with Phantasy Star Online Blue Burst (corrupt mipmapping)
- Issue with D3D8 device capabilities and SYSTEMMEM vertex buffers are fixed (LKCC demos)
- D3D8 DrawIndexedPrimitive bug fixed (Syberia 2)
- Adding support for depth buffer format D24X4S4 (D3D8) (Matrox Parhelia Reef Tech Demo)
- Adding support for volume textures (D3D8), though with limited number of formats (Matrox Parhelia Coral Reef Tech Demo + DX8 SDK VolumeTexture sample + general)
- Lower resource usage is partly included in this version. For the time being, only the usage of GPU accessible system memory.
- General bugfixing, like unexpected forced windowed mode (Soulbringer movies), vertex shader (missing fog in Colin McRae Rally), non-perspective polygon drawing bug, fixed (Zanzarah The Hidden Portal), and a lot other
- Handling depth buffers had some bugs at FL 10.0, fixed (D3D11)
- Potential bad driving of D3D11 at FL10.1 when no resolution and MSAA is forced (D3D11) (Gorky17)
- Some (regression and other) bugs in the D3D11 renderer are fixed
- GeForce 4 profile is slightly modified to match a real GF4
  - Now light beams in Splinter Cell 1 should be rendered correctly through the GF4 card type (unblurred lights with occlusion)
- 2 new videocard types are added:
  - GeForce FX 5700 Ultra (keeps the soft shadows for Splinter Cell 1 (because I like it :D) and will hopefully be feasible to provide place for new features later)
  - Matrox Parhelia-512 (for Matrox Coral Reef Demo 1.1 and other Matrox tech demos)
Glide:
- Glide fix (far background in front of the 3D world: Mig29, Uprising)
- Texture memory report is modified to match that of a real 3Dfx driver (Slave Zero)
Tons of code changing for new features that are not ready yet and so not included in this version

2.53

Support for 'dynamic resolutions' (see section 'Resolution overriding')
Added support for 'd3dcompiler_47.dll', so Win10 users don't have to download and mess with d3dcompiler dll, 47 is part of the Win10 OS.
Linear filtering was applied for upscaling the output-image even if the scale ratio was 1.0, fixed
Some modifications on the CRT-like shader were done for correct CRT-like appearance on high-res displays like a 4K monitor
Glide mode 'Compare to bias' is fixed (Esoteria demo)
Some other Glide rendering issues are fixed (Hype - The Time Quest)
DDraw system memory surface pitch is fixed to match that of DIBs (Snow Wave Avalanche)
A DX8 bug is fixed, so Mafia now works, altough I experience z-buffer glitches here and there (to be fixed)
Lot of general D3D/D3D8 bugs are fixed, too
GeForce4-style shadow buffering is reverse engineered and implemented in the 'Geforce Ti4800' preset
Floating point arithmetic differences (incompatibilities) between vs1.x and vs4.x are resolved, Splinter Cell 1 now works in shadow buffer mode
New dynamic vertex buffering algorhythm for removing rendering performance bottleneck, better usage of GPU
The config application is now per-monitor DPI-aware, to have sharp appearance
MSAA option name 'Auto' is changed to 'App driven'
New option for DirectX emulation is added (No texture filtering)
Changes in the default config:
- Capture mouse is on
- MSAA is app driven
Doc format is changed from txt to html and content is revised

2.52

Support for new output APIs are added
- Direct3D11 at feature level 10.0 (there are some restrictions)
- Direct3D11 Microsoft WARP renderer
Support for rendering DirectShow movie playback
Resolution overriding for DirectX emulation is now available
New scaling mode (forced 4:3 aspect ratio) with/without CRT-like appearance is added
MSAA support for DX8
Lot of DX8 bugfixings
A few DDraw/D3D bugfixings
Making 'VertexLayout' functionality be compatible with a real 3Dfx driver (Glide3)

2.51

Point sprite support for DX8 is added
New texture formats (A8, L8, A8L8) for DX7/DX8 are added
Tons of DX8 bugfixings, more compatibility
More DirectDraw compatibility in object handling + bugfixing
Regression bugs in Glide fixed
Capabilities of GeForce Ti 4800 and ATI Radeon 8500 are changed to be much closer to the real ones (see the technical details in the DX readme)
AMD driver bug causing driver crash with Glide rendering is workarounded now dgVoodoo should work on all AMD cards properly
'Fast video memory access' is now compatible with Unreal engines
Emulated method of stretching the display output with keeping aspect ratio is added

2.5

First version of D3D8 implementation is added
Lot of bugs fixed during general DirectX code refactoring, I don't want to detail them all here
Dynamic shader compiling for all API components for better performance (see Usage and DirectX readme for details, you'll need D3DCompiler_43.dll for this feature)

2.45

Heavily refactored DirectX emulation code for certain planned features

Full cooperating between Glide and DirectX

DirectDraw emulation:

True multidevice support, more robust DDraw emulation
OLE interface support for DirectDraw
DXTC (S3TC) block compression encoder is added, full support for possible alpha-format conversions
Two new video card types are added with slightly different properties (GeForce4 Ti 4800, ATI Radeon 8500)
DirectDraw emulation-only mode could fail, fixed
Various DirectDraw bugs/incompatibilities are fixed
Blitting bugs fixed + full support for blitting from primary surface

Direct3D emulation:

New colorkeying method added and existing colorkeying related bugs are fixed
Bugs in rendering from execute buffers (points/lines), fixed
Bug in handling state blocks, fixed

Glide rendering:

Resolution extension support (idea and technical concept by VEG and Zeus)

2.44

DirectX emulation:

Some surface/D3D device related bugs are fixed
Mirrored blitting was broken, fixed
24bit software surface support is added
support for DXT1-5 compressed textures is added but an S3TC encoder is still missing for the cases when a compressed texture is the blitting target
Transforming normal vectors was incompatible with MS D3D, fixed This fix includes enabling/disabling of normalizing them, default was wrong for older than DX7 interfaces
Colorkey blend capability is added
support is added for old mode-X display modes
Various other small bugs fixed that I can't remember of

2.43

DirectX emulation:

3D support for 8 bit surfaces is added (Colin McRae Rally)
Improved surface blitting, more optimal resource consuming for 3D surfaces
First version of fast surface video memory CPU-access is added
Introducing 'lost' state into the default DX behavior, with additional automatic self-restore mechanism for buggy DX applications
3D TL vertex rendering incompatibilites, fixed
Various small 3D/caps related bugs, fixed
Several other bugfixes that I don't want to word here

Other:

Some problems related to the window procedures and message handling are fixed
Names of the wrapped running DX applications were displayed incorrectly, fixed

2.42

Direct3D3 renderstate handling bugfixes (some of them were disabled)
Various DirectDraw bugfixes like object/structure version handling,
Compatibility fixings in DirectDraw surface creation functionality
Compatibility fixings in DirectDraw surface locking functionality
Compatibility fixings in Direct3D device creating
Fixing/refactoring light handling in general; now software vertex processing can handle any number of them, and also, they can be added at any index in Direct3D7
32 bit z-buffer support added
Minor Direct3D rendering bugs
Bad return code in an empty (but necessary) function on IDirect3DTexture, fixed
Missing multithreading guarding in some Direct3D3 methods, fixed

2.41

Direct3D 3 support is added; that is all Direct3D interface is supported now
Bug in the resolution enumerator in DirectDraw, fixed (classic and all other resolutions are now enumerated with all bit depths.)
Resolution combo box was buggy in the setup; couldn't enumerate anything when too much resolutions were available, fixed
Logic of selecting the refresh rate when unspecified rate is requested by the application is changed
Overridable refresh rates
Bugfixings and improvement for blitting to the primary surface in DirectDraw
Bugfixings for other general surface locking/blitting functionality
Minor DrawPrimitive bug fixed (missing triangles in Diablo II with Direct3D renderer)
Bug with monochrome lighting is fixed (discovered with Jedi Knight - Mysteries of the Sith)
Bug in surface blitting, fixed (The Settlers IV)
Bug/incompatibility fixings in surface handling in: GetAttachedSurface, EnumerateSurfaces, SetSurfaceDesc and loading textures from system memory surfaces to texture surfaces in video memory
DX wrapper is now more noshutdown-proof when unexpectedly pulled out from the process memory area; LithTech engine based games now should work (tested with Blood2 and Shogo Mobile Armor Division)
Various other small bugs fixed that I came across
Introducing 'unspecified' scaling mode. If you want to apply 'scaling but keeping aspect ratio' then select it on your graphics driver control panel and select 'unspecified' mode in dgVoodoo Setup. If it does not work then your only chance is forcing it through the graphics control panel (it all seems to be a Windows issue).
Disabling 'Bilinear blit stretch' in the default configuration. I've seen a few games where it caused more 'harm' than coolness that is why I decided to disable it by default.

2.4

DirectX rendering:

New, improved version of DirectDraw. It fully supports creating and blitting to/from textures, Z-buffers and 3D-renderable surfaces with several pixel formats. Also, general API-behavioring is more accurate to the original one because of lot of bugfixings and heavy reverse engineering.
Gammacontrol interfaces is added to DirectDraw
First version of Direct3D implementation is added and (almost) fully supports DirectX5, DirectX6 and DirectX7. For more and technical details, see the DirectX readme. Direct3D interfaces are also as carefully reverse engineered as DirectDraw ones.

Glide rendering:

Bug in handling utility textures, fixed (missing textures in South Park)
Bug with PALETTE6666 extension fixed (unreadable menu text in Need For Speed - Porsche 2000 with a Voodoo2 or higher)
Bug with tripebuffering fixed (missing 3D elements in The Tainted)
Adapting Glide3 to 3Dfx mini GL driver (3Dfxvgl.dll), (American McGee's Alice):
Lowering gamma bitnum to 8 (3Dfx didn't follow his own rules...)
Some init/exit code could get stuck because they can get called from DLLMain, fixed

Setup:

'Apply' button in the setup is added (I got bored to OK'ing and reopening the setup each time I want to modify the config of more folders or running instances)

2.32

Possibility of overriding the application resfresh rate is added
Small Glide3 fix (bug with Turok 2)
Minor Glide3 shader modification (SurfDemo)
Glide lib is made thread-safe at the needed (minimal) level (means avoiding crashes at certain circumstances where the original 3Dfx driver survived beause of its architecture; a Turok 2 issue again, using background threads)

2.31 - It is a slight patch version for 2.3:

Fixing Glide 3DF reader for various line ending types (Crazy Marbles)
A bug found in one of Glide state setting functions, fixed (Crazy Marbles)
Hidden/shown cursor glitch is (seems to be) fixed in windowed mode
Possibility of forcing progressive scanline order on output display is now available in the setup
Fixing some DirectDraw bugs thanks to other pending developments (what I don't want to release yet)

2.3 - This won't be easy because I suspended developing for a few months, but:

First I refactored the code in order to any new driver component or renderer could be added easily
Fixed some issues with multiple video cards/monitors. Now it works OK in a multi-videocard system (not so frequent usecase but I like if something is done well)
Added first version of DirectDraw component to the driver
Minor Glide shader modifications

2.2

Napalm build added
Glide3 fixings: erroneous clip coord space handling
Small bug related to lfb write with active pipeline, fixed
Setup got revamped a bit

2.15

Full support for texture buffers via Glide3 extension 'TEXTUREBUFFER' All 16 bit texture formats are supported as rendering format except for paletted ones
Bad color order for delta0 color, fixed (seems I'm not in luck with RGBA order in general)
Some bugs are fixed I found through my own tests: unwritten alpha values to the aux buffer, bogus Glide3 viewport handling
More optimization in LFB lock handling to avoid slowdowns on locking patterns/usage like in King's Quest: Mask of Eternity (Thanks for the feedback & help, Andrew!!)
A lot of code changed thanks to other developments, so I hope I have not broken anything

2.14

Unified Memory Architecture (UMA) along with TEXUMA Glide3 extension is supported
Some Voodoo hardware properties are changed according to UMA/non-UMA architecture
(Now Extreme Assault works with Gulikoza's latest patch, but see Tips for more)
Optimizations for lfb read/write region (including 3Dfx watermark)
A missing thing from PCI emulation is implemented for perfect lfb access with active pixel pipeline

2.13

Improved PCI emulation for LFB access: heavy lfb-lockers like Carma1 and Pyl SHOULD run much smoother now (see Tips for more)
Glide3 fixings: bad color order with packed RGBA, uninitialized texchroma state
General glide fixings: bug in glide setstate and clip rectangle
Missing feature "fog with iterated z" is implemented along with minor shader modifications
Support for splash screen and shameless plug: dgVoodoo needs the 3Dfx splash dlls to get it working (3DfxSpl2.dll, 3DfxSpl3.dll, all with version 1.0.0.4), however I did not include them in the core dgVoodoo pack
Minor modification for DosBox
TMUnum selector combobox is fixed, I fcked it down last time

2.12

More shader optimizations: most critical ones are reduced to 90% in size again (So, by now, their size are 65% of the original. I hope I have not messed up anything with them.)
Optional 16 bit depth buffer (see Tips for why is that)
Some fixings in Glide3 thanks to some unexpected API-driving (scene demo Virhe)
Some bugs related to maintaining/switching/handling windowed/fullscreen state are fixed
Voodoo2 with 1 TMU is no longer selectable in the setup; A Voodoo2 always have 2 TMUs and it is the default now because shaders are optimal enough now to handle 2 TMUs

2.11

Refactoring GPU querying to get it to work with ATI drivers (ATI does not seem to handle them correctly, my code was always fooled into infinite loop at a certain point)
Further shader optimizations: most critical ones are reduced to 90% in size
Minor cursor-issue related to losing window focus, fixed

2.1

Potential stalling rendering (even on fast GPUs) when switching screen modes, fixed
Shader optimizations: most critical ones are reduced to \~80% in size
Ability to configure running Glide wrapped applications dynamically (see section 'Configuring')
Different exposed capabilities according to the selected card type
More Dosbox compatibility
Bug in gammaramp handling, fixed
Bug in fogtable generating code, fixed
Bug in PCI access emulation, fixed
Forced vSync is enabled by default to avoid overkilling the GPU with wild-rendering applications

2.01

Undrawn polygons when updating TMU memory, fixed
Potentially bad drawing of strip-primitives in Glide3, fixed
Malfunctioning LFB lock with 32bit formats when PCI emulation is enabled, fixed
Fullscreen/Windowed state was not always remembered between Glide-initializings, fixed

2.0 - The original version