From 6fe80a1c3636cedf2ddb05ffded21412e2abf1da Mon Sep 17 00:00:00 2001 From: Dege Date: Thu, 24 Sep 2020 14:15:55 +0200 Subject: [PATCH] docs added --- .vs/slnx.sqlite | Bin 90112 -> 90112 bytes QuickGuide.html | 196 +++++ Readme.html | 1889 ++++++++++++++++++++++++++++++++++++++++++++ ReadmeDirectX.html | 754 ++++++++++++++++++ ReadmeGlide.html | 442 +++++++++++ 5 files changed, 3281 insertions(+) create mode 100644 QuickGuide.html create mode 100644 Readme.html create mode 100644 ReadmeDirectX.html create mode 100644 ReadmeGlide.html diff --git a/.vs/slnx.sqlite b/.vs/slnx.sqlite index 8653fa3d6764e3a093d9f205596e48baacbf53d9..f0412ab3e1f6e9733534b812e46371c80c5485f7 100644 GIT binary patch delta 494 zcmZoTz}j$tb%Hdb&_o$$Mxl)flk^#RHh2L5UM75u6EuKbGp zOnlGzj`A(tEU3`RS1-rI#-Pi<$rhBFn39|7o|Bo9s+Uoco5OJku zyh~gLdCQf6_Q+R49aj72&qWBOj%Ag25q2JU}o zh6;n-!X?bC&4}gz&dD|L9YAXjGw}c6{|*eG7yOTbmY(H50kr%R|6Ts;Kx-HCi?A>= zF!F#1ZV=KKw8FP59-2TL1Bdh_dK1 hU^-cx#SkWn;${IBWtcd`(IPC`3>dE7TvXrp001}8l(7H+ delta 147 zcmZoTz}j$tb%Hb_-$WT_M!t;+lk^!mHhaWHAM=0W uzsr9eD7&A3^7VXOpllHX{}28}{HytU_>1`W^PlH`36zcE-&|DR_W%G_TQUOx diff --git a/QuickGuide.html b/QuickGuide.html new file mode 100644 index 0000000..0bc317d --- /dev/null +++ b/QuickGuide.html @@ -0,0 +1,196 @@ + + + + + + + + + + dgVoodoo2 Quick Guide + + + + + + +

+===============================================================================
+dgVoodoo2 Quick Guide
+===============================================================================
+

+ +If you are new to this wrapper: + +
    +
  • Q: What is dgVoodoo? And where is the installer?
    • +
  • + A: dgVoodoo consists of components substituting the implementations of various graphics API's like 3Dfx Glide and Microsoft DirectX up to version 9.
    + Currently it has no installer and its usage is intended to be drop-in: just copy the graphics API dll's from dgVoodoo package next to your game/application + executable and run it. You need a graphics card supporting DX10.0 as a minimum.

    +
    • +
+
    +
  • Q: So how can I use it exactly for my old games or other applications?
    • +
  • + A: If your game is a 3Dfx Glide one then just copy +

      + +
    • Glide.dll
      • +
    • Glide2x.dll
      • +
    • Glide3x.dll
      • +       +

    + from the 3Dfx\x86 folder to the same folder where your game executable is in. If it's a 32bit DirectX application then copy +

      + +
    • DDraw.dll
      • +
    • D3DImm.dll
      • +
    • D3D8.dll
      • +
    • D3D9.dll
      • +       +

    + to the game folder from the MS\x86 folder. If you don't know which API your game uses, or it uses both Glide and DirectX then just copy all the dll's listed above.
    + For 64bit Direct3D9 applications use +

      + +
    • D3D9.dll
      • +       +

    + from the MS\x64 folder.
    + IMPORTANT: Do not copy 3Dfx or MS folders themselves but only the dll files. +
    • +
+
    +
  • Q: That's all?
    • +
  • + A: Yes, you can run your game. dgVoodoo should get in action with its default configuration and render your game as a D3D11 one. Altough dgVoodoo is configurable (see below), +its default configuration is recommended for first try because this configuration is the one that provides the circumstances the games were designed for. +
    • +
+
    +
  • Q: OK, my game is running but the image is stretched on my screen...
    • +
  • + A: Most of the old games is designed for display output aspect ratio of 4:3 and if you have a widescreen monitor then their image will likely be distortedly stretched along +the screen, which is not good. The recommended way to fix it is forcing 'keeping aspect ratio' in the control panel of your graphics driver (like nVidia Control panel for nVidia graphics cards). +
    • +
+
    +
  • Q: My graphics driver doesn't support overriding aspect ratios... Is there any other fix to this?
    • +
  • + A: Yes, there is. dgVoodoo is configurable and has various scaling modes. You should try that. +
    • +
+
    +
  • Q: How can I configure dgVoodoo?
    • +
  • + A: dgVoodoo reads the configuration from a config file named dgVoodoo.conf. +How to create one? Well, while dgVoodoo now has a human readable text format config file, you also have the dgVoodoo Control Panel application to render and modify the content of +those config files in a convenient GUI way. So, copy dgVoodooCpl.exe to your desktop or any other folder you prefer and start it. You'll see three different tabs set to the default +configuration. If you change something and press OK or Apply button then the CPL writes the current configuration into a config file. +Where it saves that?? To the folder you select on the Config folder / running instance rolldown menu at the top of the CPL. By default it chooses your login-user appdata folder + but you can add extra ones manually, say add and choose your game folder if you want your config file be created there. For now, let's just use the global appdata folder because dgVoodoo finds the configuration +file there if none was found in your game folder.
    +So, let's modify dgVoodoo's scaling mode from Unspecified to Stretched, keep Aspect Ratio and run your game again. You should see the game running at a +preserved 4:3 aspect ratio without problems and it's done.

    + +
    • +
+

+

    +
  • Q: But wait, at all, how do I know if my game is being rendered through dgVoodoo?
    • +
  • A: Windows doesn't support 3Dfx Glide natively, so if you see a Glide game running then it must be running through a Glide wrapper. dgVoodoo or something else.
    + For DirectX games dgVoodoo tags its own small logo to the right-bottom corner. If you see that logo then the game is surely rendered through dgVoodoo. +
    • +
+
    +
  • Q: Cool, now I want to improve the appearance of my game. How to change the resolution and how can I apply some antialiasing?
    • +
  • + A: You can, but first of all, you should always set the resolution or antialiasing in your game options menu if it's available there.
    + If not, or the game has bad UI-scaling then you can try to force it externally through dgVoodoo. You have various options for resolution on Glide and DirectX tabs, so + just select there what you want. For antialiasing, dgVoodoo currently only supports MSAA. If you want some other method (or any other fancy image post-process) then you likely need ReShade. + The other thing you should know is forcing resolution or MSAA can easily cause unwanted glitches in the appearance, or, as for some games, performance loss or simply erroneous rendering. That's why I said 'try'.

    + + +
    • +
+
    +
  • Q: So, dgVoodoo has no image post processing at all? What is more, I'm little confused about various resolutions... How dgVoodoo's image output work exactly?
    • +
  • + A: First, frames are rendered at the forced resolution instead of application resolution. After that, some optional post process effect take place like deframing, dithering and color adjustments. + This image can be pixel multiplied and then finally either presented to the display output, or scaled into your desktop resolution and presented to the display output. Depends on the scaling mode.

    + +
    • +
+
    +
  • Q: Should I know any extra about the configuration?
    • +
  • + A: It may seem there are plenty of options to play with, but for a quick try and basic usage you shouldn't deal most of them. Setting a scaling mode and forcing resolutions and vertical sync are enough in general. + If you want to get deeper knowledge about dgVoodoo then read the detailed docs in the Doc folder. +
    • +
+ + + + \ No newline at end of file diff --git a/Readme.html b/Readme.html new file mode 100644 index 0000000..2116f6a --- /dev/null +++ b/Readme.html @@ -0,0 +1,1889 @@ + + + + + + + + + + dgVoodoo2 Main Readme + + + + + + +

+===============================================================================
+dgVoodoo 2.7: Glide and DirectX API libraries implemented on D3D11/12
+Released: September 14, 2020
+Author: Dege
+
+Copyright (c) 2013-2020
+===============================================================================
+

+ +

+

+Table of contents +

+

+1. Redistribution rights
+2. Features
+3. Requirements
+4. Test results
+5. Usage
+6. Configuring
+7. Resolution overriding
+8. General options
+9. General additional options
+10. Direct3D 12
+11. General tips and known issues
+12. Special release version with debug layer
+13. Change log
+

+===============================================================================
+ +

+ +
+

+1. Redistribution rights +

+

+Files of dgVoodoo can be redistributed freely as far as they are kept together, +remain unmodified and unrenamed. Namely, only the full package can be +redistributed in the form as it is! +

+

+If you would like to utilize them in publicly available custom solutions or +packages, like game patches or anything else, then PLEASE ask me for permission, +furthermore mention its original source in your package along with the following +download link: +

+http://dege.fw.hu/ +

+Official dgVoodoo forum where you can contact me and the dgVoodoo community is at: +

+http://www.vogons.org/viewforum.php?f=59/
+
+Tip: See topic "WIP versions" for checking out new dgVoodoo versions that are not officially released. +

+ + + + + + +
---------------------- !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ----------------------
+

+Very BIG THANKS must go to the community of Vogons for helping me a lot in +testing during the development! Thanks Guys, I couldn't have proceed so far +without such a great quality assurance! +

+
+

+And I append a new sentence here to emphasize it again, especially for testing +my D3D8/9 implementation and supplying me with ideas, tips and various informations +on several games!!! +

+
---------------------- !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ----------------------
+ + +
+

+2. Features +

+

+dgVoodoo 2 is a set of old graphics API's implemented for Windows Vista/7/8/10. +

+They are implemented on Direct3D 11/12 and they can use different device types as wrapping output: +

    +
  • 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).
+Glide libraries basically can work in two ways: +

    +
  • Using their precompiled shaders - it is the less efficient mode (legacy)
    • +
  • Using an external HLSL shader compiler - this is the most efficient and recommended mode and referred as 'dynamic shader compiling'
    • +
+

+

+If dynamic shader compiling is available (see Usage) then dgVoodoo can work +with specialized shaders requiring much less GPU power, providing much better +performance, especially on weaker video cards.
+

+ +
+

+3. Requirements +

+
    +
  • 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
    • +
  • HLSL shader compiler (D3DCompiler_43 or D3DCompiler_47)
    (note that D3DCompiler_47 is part of Windows 10)
    • +
+ +
+

+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 (feature level 10.0 only)
      • +
    • 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
      • +
    + If dynamic shader compiling is utilized then dgVoodoo generally performs quite well on all hardware except + integrated chips (like Intel HD 2000 and 4000).
    + Using only precompiled shaders requires a mid-class video card at least, and the low-end ones (intended for office-like usage) like + Geforce GT 610 and AMD HD 6450 are not recommended. +
    • + +
  • 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. +

+

+If you use dgVoodoo on Windows 10 then dynamic shader compiling is automatically +available because D3DCompiler_47 is part of the operating system.
+For preceding Windows versions (Vista, 7, 8) you need to download it manually and +then, you can copy this dll into each game folder next to the wrapper dlls but the +best practice is to copy it into +

+ +
    +
  • Windows\System32 folder for 32 bit operating systems
    • +
  • Windows\SysWOW64 folder for 64 bit operating systems
    • +
+ +

+if it is not already there by the result of the installation of some +other software.
+Note that dgVoodoo supports both D3DCompiler_43 and D3DCompiler_47. +_43 is supported only because of compatibility with users having it +downloaded and copied into their system folder previously. +

+

+Utilizing dynamic shader compiling is only recommended for Glide libraries (unlike with previous dgVoodoo versions). +DirectX implementations have their own internal DXBC generator which proved to be good enough +so support for the external compiler has been removed. +(I would like to completely ditch the external compiler once the internal code generator is implemented for Glide as well.) +

+ +
+

+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)
      • +
    +

    +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
      • +

    + 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
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
UnspecifiedCenteredStretchedStretch with AR
MaxAS (A, D)AS (A, D)DAS (A, D)
Max ISFIAS (A, D)IAS (A, D)* remarksIAS (A, D)
Max FHDAS (A, min (D,F))AS (A, min (D,F))min (D,F)AS (A, min (D,F))
Max FHD ISFIAS (A, min (D,F))IAS (A, min (D,F))* remarksIAS (A, min (D,F))
Max QHDAS (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))* remarksIAS (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). +

    • +
+ +
+

+8. General options +

+
+Options on the General tab affects all wrapped APIs, that is, currently +Glide and DirectX. +
    +
  • Output API
    + Six output API's are available:
    +
      +

    • 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 a little limitation and affects only D3D8/9: +

        +
      • Max texture size is 8K x 8K
        • +
      +
      + D3D11 with FL10.0 is designed to be used with late + DX 10.0 hardware and has some limitations: +
        +
      • No mipmapping in Glide rendering
        • +
      • Limited operations on Z-buffers
        • +
          +
        • 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
    + When this option is enabled then dgVoodoo won't change the physical + gamma ramp of the screen but instead it solves the color adjustments + just like in windowed mode and so your pre-configured color profile(s) + for the given monitor(s) remain(s) preserved. 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. +

    • + +

  • 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. +

    • +
  • 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-2: Smooth and sharpest result - it can produce stronger halation than Lanczos-2
      • +
    +

    • +
  • 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. +

    • +
  • 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. +

    • +
  • EnableGDIHooking +

    Very experimental option - when enabled dgVoodoo hooks some GDI functions to achieve displaying game cutscene movies rendered + through GDI (relying typically on the old AVI player lib) +

    • +
+ +
+ +

+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 is broken with AMD GPU's (DirectX modules). I got a ton of reports complaining about + solid colored polygons instead of textured ones. This problem seems to affect all + GCN 2 and newer GPU's and I cannot do anything about fixing it. I don't have a clue what change in my code + broke it and AMD probably won't fix their drivers so I don't care about it all anymore.
    + On the other hand, according to the feedback I got, D3D12 works as expected so this is your + best bet on AMD hardware. +
    • +
    +
  • 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. +
    • +
    +
  • Implied by the previous point, D3D12 swapchains do not support gamma ramps as well. dgVoodoo can apply gamma + as a postprocess effect but I didn't want it to be always forced to have effect (to get max fps's for games + that don't really need gamma calibration) so it only works if option 'Inherit Color Profile in full screen mode' + is enabled (see General options). +
    • +
    +
  • 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. +
    • +
    +
  • If you have multiple displays attached to different GPU's (rare case) then you can run into an + unexplainable initialization fail with certain games. D3D12 swapchains suffer from more restrictions than + D3D11 ones which the current version of dgVoodoo cannot handle well. Enable only one of your video cards + (see General options) and it should fix the problem. +
    • +
    +
  • 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. +
    • +
    +
  • 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. 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.
    • +
    +
  • Fullscreen gamma ramp may not be supported by your card. nVidia and ATI seem + to handle it as expected but (e.g.) Intel does not.
    • +
    +
  • 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. :( +
    • +
+ +
+ +

+12. 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. +
    • +

+ +
+ +

+13. Change log +

+ +
    +
  • + 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,
      • + surface blitting, basic ROP codes are added, and others + +
    • 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 +
    • +
+ + +Have luck,
+ +Dege + + +
+ + + + + \ No newline at end of file diff --git a/ReadmeDirectX.html b/ReadmeDirectX.html new file mode 100644 index 0000000..e34c86e --- /dev/null +++ b/ReadmeDirectX.html @@ -0,0 +1,754 @@ + + + + + + + + + + dgVoodoo2 DirectX Readme + + + + + + +

+===============================================================================
+dgVoodoo 2.7: DirectX emulation related stuffs
+
+===============================================================================
+

+ +

+ +

+Table of contents +

+

+1. Important notes
+2. General overview
+3. Some technical info
+4. Application resolutions and refresh rates
+5. About fullscreen and windowed mode
+6. DirectX options
+7. DirectX additional options
+8. Tips and known issues
+9. Why doesn't dgVoodoo DX emulation start up? +

 +

+===============================================================================
+ +
+

+1. Important notes +

+ +

+First of all: NEVER COPY DDRAW.DLL, D3D8.DLL and D3D9.DLL INTO SYSTEM FOLDERS!! +ALWAYS USE A LOCAL INSTALLATION FOR A GAME!
+DirectDraw, D3D8 and D3D9 are still existing and widely used system components in Windows. :)

 + +For clarifying, let's see what dlls MS and dgVoodoo use for DirectDraw and +Direct3D: +

+
    +
  • + + MS:
    +     + + + + + + +
    ddraw.dll- Contains all DirectDraw implementations up to version 7
    d3dim.dll- Contains all Direct3D implementations up to version 6
    d3dim700.dll- Contains Direct3D 7 implementation
    d3d8.dll- Contains Direct3D 8.1 implementation
    d3d9.dll- Contains Direct3D 9Ex implementation
    +
    • +
    +
  • + + dgVoodoo:
    +     + + + + + +
    ddraw.dll- Contains all DirectDraw implementations up to version 7
    d3dimm.dll- Contains all Direct3D implementations up to version 7
    d3d8.dll- Contains Direct3D 8.1 implementation
    d3d9.dll- Contains Direct3D 9.0c implementation
    +
    • +
+ +

+So, dgVoodoo packs all of its pre-D3D8 implementation into one module, d3dimm.dll, +which differs in name from the MS one (note the extra 'm' in the name).
+Thus, copying it to the system folder by accident won't cause any harm. In spite +of that, it is not recommended. +

+ +
+

+2. General overview +

+

+If you want to wrap an old DirectX stuff then just copy dgVoodoo's dlls to the +application folder and launch that. DirectX rendering is configurable similarly +to Glide. (See DirectX related CPL options) +DirectDraw is usable without Direct3D but there are no 3D rendering capabilities +exposed to the applications in that case.
+Direct3D8/9 are standalone components, no need for DirectDraw to use them. In spite of +that it is a good idea to copy DDraw.dll along with D3D8.dll (and maybe D3D9.dll) because a lot of movie +playback system (e.g. DirectShow) rely on DDraw even in D3D8 games. dgVoodoo DDraw +and D3D8/9 has the ability and internal support to cooperate if the situation requires. +
+
+All the interfaces of old DirectX (that is, all DirectDraw interfaces and +Direct3D 3/5/6/7/8/9 interfaces) are almost fully supported, and existing implementation +is improved version by version by more and more reverse engineering and finetuning. +
+
+Since DirectX is not a pure hardware-only rendering API, basically two types of +virtual video cards can be used, like back in the old days, hehe. Four extra +video card types are added to utilize different chipset features and provide correct +vendorID/hardwareID. +Available video card types: +

+
    +
  • + One that simulates an old SVGA with hw-capabilites only for 2D blitting + operations.
    With such a card, only a software 3D rendering device can be used. +
    • +
    +
  • + One (imaginary) video card that has its custom hw 3D rendering support.
    + This card provides support for full hardware acceleration including + 'Transform & Light'. +
    • +
    +
  • + GeForce4 Ti 4800 +
    • +
  • + ATI Radeon 8500 +
    • +
  • + Matrox Parhelia-512 +
    • +
  • + GeForce FX 5700 Ultra +
    • +
+ +

+For more detailed capabilities, see the technical info. +

+Software rendering devices does not use real software rendering in dgVoodoo. I +think that a software rasterizer has no reason for existence nowadays and didn't +want to write one just for fun so they use hw accelerated rendering in the +background. The point is, towards the applications they logically appear as +software devices. +

+DirectX renderer needs less GPU power (for general cases) than Glide renderer and +has its own internal shader code generator for generating specialized shaders. +

+DX emulation has a method for fast CPU-access of locked surfaces. The current +method is not the final version and going to be improved later. +The reason of not using that one all the time but it is up to the user's choice +is that this method is not 100% safe and can cause crashes under certain +circumstances. It depends on the wrapped application. +

+Important to note that compatibility with MS DirectDraw is not completely +guaranteed, especially with very old applications written in the win95/Win98 era. +Those applications might utilize DirectDraw/GDI interaction which is not fully +supported in dgVoodoo. I would like to improve that somehow, in later versions. +

+ +
+

+3. Some technical info +

+ +

+I say 'almost fully supported' when talking about DX support because there are +some functions on certain interfaces of which functionality is somewhat unclear +or totally unimportant, so they either not implemented at all or just +partially because I did not have time and patience to figure out their exact +behavior. Think about a total of 5-6 functions of all the DX interfaces, +I hardly believe that anything used them. +

+For D3D8.1 and D3D9, the following features are not implemented but planned to be in the +future: +

+
    +
  • Higher-Order Primitives (maybe some day)
    • +
  • Full D3D9Ex functionality
    • +
+ +

+................................................................................ +

+ +Internal virtual 3D card has the following 3D hardware capabilities: + +

+ +
    +
  • Supports transforming and all kind of lighting with flat, Gouraud and Phong + shading, max 8 active lights
    • +
  • Supports 6 clipping planes
    • +
  • Supports vertex bending with 3+1 weights
    • +
  • Supports matrix palette of 256 elements for indexed vertex blending
    • +
  • Supports texture coordinate generating & transformation, projective texturing
    • +
  • Supports all contemporary pixel formats for textures and render targets with + four different RGBA order (altough the order is not yet exposed in the CPL app)
    • +
  • Supports compressed textures (DXTC1-5)
    • +
  • Supports volume textures with limited number of texture formats
    • +
  • Supports Z-buffer (of course) and stenciling (but there is no W-buffer)
    • +
  • Supports vertex and pixel fog
    • +
  • Supports colorkeying with one texture (with colorkey blending or + colorkey discarding)
    • +
  • Supports all texture sampling modes
    • +
  • Paletted textures
    • +
  • Depth textures
    • +
  • 16 vertex streams
    • +
  • Vertex tweening
    • +
  • Supports point sprites
    • +
  • Full SM1/2/3 and DX9-level fixed function pipeline support
    • +
  • 256, 512 or 1024 vertex shader constants (configurable)
    • +
+ +

+The other 4 card types are not an exact emulation of the given chipsets with some +real ATI/nVidia/Matrox driver version. They are just present to bias the available +rendering capabilities and properties toward a real ATI, nVidia or Matrox card: +

+ +

+GeForce4 Ti 4800 capabilities: +

+ +
    +
  • Same as the internal virtual 3D card, except:
    • +
  • No 32 bit z-buffer support
    • +
  • Full cut colorkeying
    • +
  • No indexed vertex blending
    • +
  • Maximum supported pixel shader version is ps1.3
    • +
  • Max 96 vertex shader constants
    • +
+ +

+ATI Radeon 8500 capabilities: +

+ +
    +
  • Same as the internal virtual 3D card, except:
    • +
  • No 32 bit z-buffer support
    • +
  • Plain colorkeying
    • +
  • Max 57 matrices for indexed vertex blending
    • +
  • No paletted texture support
    • +
  • 8 vertex streams
    • +
  • Max 192 vertex shader constants
    • +
+ +

+ + Matrox Parhelia-512 capabilities: + +

+
    +
  • Same as the internal virtual 3D card, except:
    • +
  • No 32 bit z-buffer support
    • +
  • Plain colorkeying
    • +
  • No paletted texture support
    • +
  • Maximum supported pixel shader version is ps1.3
    • +
+ +

+ + GeForce FX 5700 Ultra capabilities: + +

+
    +
  • Same as the internal virtual 3D card, except:
    • +
  • No 32 bit z-buffer support
    • +
  • Full cut colorkeying
    • +
+ +Since I cannot enumerate all the capabilities here, check them out with DXCapsViewer if interested.
+Also, those capabilities might be changed in the future if I get more accurate information about the hardwares in question. + +

+................................................................................ +

+DirectDraw and Direct3D objects supports all types of rendering devices that are +supported in original DirectX.
+Direct3D8/9 support HAL and software device types. +

+In MS pre-Direct3D8 implementations Direct3D7 is the only one that can be used with +hardware vertex transformation and lighting, through a Transform & Light (T&L) +device (but I guess it casually falls back to software vertex processing if the +device driver does not support the complete vertex operation pipeline that is +currently set). +

+In all other cases software vertex processing is used. In dgVoodoo vertex +processing is always routed to the hardware when possible.
+However, it's not so simple: software vertex processing is unavoidable in Direct3D +in some cases, for example when an application wants Direct3D to do only vertex +processing without rendering or to calculate visibility, or, when the rendering +extent must be updated when drawing primitives through a non-T&L device (this is +not too important in practice but I included it because of full compatibility). +Also, vertex processing for Direct3D3 can only be done in software because of the +execution logic of execute buffers.
+It all means that dgVoodoo has a software T&L vertex processing engine like +MS Direct3D for such cases, duplicating the hw functionality. However for +transforming, bending, lighting, fogging and texture coordinate transforming +calculations dgVoodoo uses fast vectorized SSE2 code instead of scalar FPU. +

+(It should be noted that in newer DX version like DX7 MS uses SSE2 too. + What is more, for software emulation of vertex shader code in DX8/9, MS seems to + apply an internal compiler, that compiles from shader code to x86 bytecode. + Wow, what a nice feature!! I should do the same, but probably it all is not too + relevant on modern CPUs.) +
+
+ +Phong shading (per-pixel shading) is not supported by MS Direct3D, only +Gouraud (per-vertex). However the internal virtual 3D card can externally be +forced to Phong shading through the CPL app but keep in mind that it can cause +heavy GPU usage because Direct3D lighting is quite complex, typical hardware +implementations supports 8 active lights with a lot of properties and components. +Also, Phong shading is only applicable when the application commits all its +transforming and lighting calculations to the D3D runtime. Unfortunately it is +very common that games do their own T&L calcs and use D3D as a lowlevel rasterizer +for the rest. It is especially true when a game is written for multiple platforms +or multiple 3D APIs like Glide, D3D, OpenGL, etc. Direct3D3 always uses software +vertex processing so Phong shading cannot be applied there at all. +

+DX8 is a horse of another colour from the beginning of a new era. Applications +written for that usually heavily utilize multiple vertex streams through real +vertex and index buffers along with built-in hw T&L pipeline and/or shaders +without any calculations done in software. I think I shouldn't detail DX9. +It's a way too new API compared to the previos ones. :) +

+Phong shading is only applicable with full fixed function vertex/pixel pipeline +usage. If an application is rendering through a vertex and/or pixel shader in DX8/9 +then Phong cannot be utilized. +
+ +

+ +
+

+4. Application resolutions and refresh rates +

+ +

+An application using DirectX can only detect available resolutions and +associated refresh rates by asking DirectDraw/DX8/DX9 to enumerate them. There are two +slight problems with it in practice: +

+
    +
  • Modern hardware does not necessarily report some low resolutions like 320x200, + 640x480, etc.
    • +
  • Old hardware was not able to report refresh rates or query the current one in + general, back then when 60/75Hz CRTs were the standard displays. Thus, most of + the games/applications just used 0 for refresh rate when setting the resolution + which means 'unspecified or default' refresh rate.
    • +
+ +

+To workaround the first case, dgVoodoo keeps a list of 'classic' resolutions. +These are the following: +

+ + +
    +
  • 320 x 200 (X-mode is also supported in DDraw)
    • +
  • 320 x 240, (X-mode is also supported in DDraw)
    • +
  • 640 x 400,
    • +
  • 640 x 480,
    • +
  • 800 x 600,
    • +
  • 1024 x 768,
    • +
  • 1280 x 1024
    • +
+ + +

+If a resolution of that list is not amongst the ones that your modern adapter +reports then dgVoodoo forces enumerating it to the application. +

+As for the refresh rates, if an application does not specify one of the +enumerated ones but specifies 0 (default) then dgVoodoo finds one according to the following precedence: +

    +
  • If General\EnumerateRefreshRate is enabled +
      +
    • The forced refresh rate (part of the forced resolution) if it's defined
      • +
    • The refresh rate of the desktop display mode in GeneralExt\DesktopResolution if it's defined
      • +
    • The current desktop refresh rate
      • +
    +
    • +
    +
  • If General\EnumerateRefreshRate is disabled +
      +
    • The current desktop refresh rate
      • +
    +
    • +
+In either case, if the chosen refresh rate is unsupported by your monitor at a given resolution then the closest supported one will be selected. +

+If you want to make sure or would like to use a custom refresh rate then +you can override that through the resolution selector combo box (DirectX tab).
+For details, see chapter 'Resolution and refresh rate overriding' in the general readme. +

+If the refresh rate is overridden then all resolutions are enumerated with the +overidden value to the applications. +

+ +
+

+5. About fullscreen and windowed mode +

+ +

+Choosing fullscreen or windowed working mode is part of the DirectDraw API. Some +games or demoscene stuffs run only in fullscreen so one could think what cool it +would be to have them running in windowed mode. I thought the same so wanted to +enable by default the same method to switch between them as used for Glide. +There are some problems however: the ways handling fullscreen and windowed mode +via DirectDraw are totally different in the aspect of the driving code. So, +forcing an application into an unexpected situation may cause glitches or crashes. +Also, a game may have its on mechanism for mode switching with which dgVoodoo +could conflict. Due to those theoretic things, and because I experinced some +problems with some games, I decided to emulate the original DirectDraw behavior +by default: when a fullscreen application loses the focus then its window gets +minimized and when it regains that its window is restored and enters fullscreen +again and no manual switch is available. Also, there are no changes applied on the +app window like style and overridden messages, etc. +

+If you make sure that a given game does not conflict with dgVoodoo's Alt-Enter +thing then you can enable that in the CPL app. Also, you can force it to windowed +mode if 'app controlled fullscreen/windowed' option is disabled at the game +startup (and choose windowed mode in the general settings), without Alt-Enter. +Forcing a windowed application to fullscreen can only be done by manual switch +because there is no way to 1) detect when an application begins its rendering and +2) switch to fullscreen. +

+(But, think about it, windowed to fullscreen does not make any sense. The +resolution used comes from the window size but the window may get resized or +repositioned when switching mode, so..., it's confusing.) +

+What is more, since DirectDraw was a one-monitor-API in practice, integrating windowed +applications in a multimonitor environment is already a problem even for MS, +I think. If such an app is even forced to fullscreen mode then it may crash or +misworks for reasons I do not want to word here. +

+Lost mode is emulated in default DX emulation mode, namely when switching +between windowed/fullscreen mode by Alt-Enter is disabled. This is because some +DX applications count on losing their surfaces when their window loses focus and +their code paths can be mislead if they remain 'unlost'. (This is a result of bad +programming technique as DX SDKs clearly state that an application shouldn't +rely on window focus lost or any other circumstances.) +

+On the other hand, there are incomplete or buggy DX applications that can't +restore when they get reactivated and just get stuck. So, introducing lostmode +emulation is up to a potential feature loss, as such applications likely worked +well with older dgVoodoo versions. In order to keep this feature dgVoodoo applies +auto-restore for the needed elements when such a situation is detected. +

+ +
+

+6. DirectX options +

+ +
    +
  • Disable and passthru to real DirectX +

    + As it says, if you want to disable DirectX without + removing dgVoodoo's DLLs then use this option. +

    • + +
  • Videocard +

    + You can select between the internal virtual 2D (SVGA) + and 3D accelerated cards. +

    • + +
  • VRAM +

    + Onboard videomemory of the selected videocard. +

    • + +
  • Filtering +

    + Various texture filtering modes can be forced here, starting from simple point sampled to high level anisotropic. + Keep in mind however that forcing other than the application default can result in rendering glitches, or it can + completely break some visual effects! +

    • + +
  • No mipmapping +

    + Disabling mipmappig (forcing largest mip texture level). +

    • + + +
  • Resolution +

    + Here you can override the application resolution and + refresh rate. See detailed explanation of static/dynamic + resolutions in the general Readme. +

    • + +
  • Antialiasing +

    + For 3D rendered surfaces you can force MSAA. + Option 'Application controlled' is meaningful only for DX8. For DDraw/DX it is equivalent to 'Off'. +

    • + +
  • Application controlled fullscreen/windowed state +

    + Since choosing this state is part of DirectDraw, you + must disable this option to control that via general + settings. +

    • + +
  • Disable Alt-Enter to toggle screen state +

    + To prevent conflicting with an application built-in + Alt-Enter handler. +

    • + +
  • Bilinear blit stretch +

    + 2D bitmap copying can involve stretching in DirectDraw. + However the applied stretching filter cannot be controlled + via the API and early hw used simple point sampling. + It can result pixelated appearance here and there but + you can force bilinear filtering which looks cooler for + most cases. But, it can also introduce various artifacts + especially when colorkeying is also applied during + blitting.
    + Try forcing bilinear texture filtering for achieving similar + effects for D3D8 games. +

    • + +
  • Apply Phong shading when possible +

    + See technical info. +

    • +
  • Force vSync +

    + Forcing vertical retrace. +

    • +
  • Fast video memory access +

    + Provides an alternative method for accessing video memory + of DX surfaces by the CPU. Try this one if an application + renders at a low frame rate. +

    • +
  • dgVoodoo Watermark +

    + Similarly to 3Dfx watermark in Glide, you can use + dgVoodoo's own one to see if something is driven through + dgVoodoo's DirectX. +

    • +
+ +
+ +

+7. DirectX additional options +

+ +
    +
  • AdapterIDType +

    You can define what type of driver version and vendor id's the wrapper should report to + the application; Some games rely on that information so it can be useful for them. + It can be defined only for SVGA and Internal3D card types; the others have their own wired + information. It can be undefined (default), nVidia, AMD or Intel. +

    +
    • +
  • VendorID, DeviceID, SubsystemID, RevisionID +

    It can be defined only for SVGA and Internal3D card types. + You can overwrite these properties even if a non-default AdapterIDType is defined. + Say, you defined an nVidia ID type but would like to refine the vendor ID. + +

    +
    • +
  • ExtraEnumeratedResolutions +

    You can define up to 16 custom resolutions that are enumerated to the application.
    + It's useful for apps that support all or a very special resolution and you want to select that through the app itself rather than force it through the wrapper externally (avoiding rendering glitches). + You can also use keywords max, max_4_3 and max_16_9 here along with refresh rates to define maximum resolutions calculated from the desktop resolution with the appropiate aspect ratio. + 'Max' defines no aspect ratio so it is practically equivalent to your current desktop resolution. +

    +
    • +
  • DefaultEnumeratedResolutions +

    What resolutions are to be enumerated to the application by default: +

      +
    • All: All of the resolutions supported by your GPU and the classic ones. (default)
      • +
    • Classics: Only the classic resolutions.
      • +
    • None: No any resolution are enumerated to the application. You must define at least one extra custom resolution in this case or the application won't see any which is a problem.
      • +

    +
    • +
  • EnumeratedResolutionBitdepths +

    You can define what bit depths for display modes are to be enumerated and supported by dgVoodoo. Any subset of {8, 16, 32} or simply All. (default) +

    +
    • +
  • Dithering +

      +
    • Disabled: Dithering is always disabled, ending up 16-bit quality rendering on 16 bit surfaces.
      • +
    • Appdriven: The application can enable and disable dithering. When enabled, the selected dithering effect is applied.
      • +
    • ForceOn16Bit: Dithering is always enabled for 16 bit targets and the selected dithering effect is applied.
      • +
    • ForceAlways: Dithering is always enabled and the selected dithering effect is applied (default).
      • +

    • +
  • DitheringEffect +

      +
    • Ordered2x2: Ordered dithering with a 2x2 dithering matrix
      • +
    • Ordered4x4: Ordered dithering with a 4x4 dithering matrix
      • +
    • Pure32Bit: 32 bit rendering quality (default)
      • +

    • +
  • DitherOrderedMatrixSizeScale - integer scale value for dither matrix size +

      +
    • 1 = normal, 2 = double size, etc.
      • +
    • 0 = automatic (the aim is to have some retro feel&look) (default)
      • +

    • +
  • DepthBuffersBitDepth +

      +
    • Appdriven: Internal bit depth of depth buffers is the same as the application defines. (default)
      • +
    • ForceMin24Bit: Internal bit depth of depth buffers is minimum 24 bit.
      • +
    • Force32Bit: Internal bit depth of depth buffers is always 32 bit. This one is not recommended.
      • +

    +
    • +
  • MaxVSConstRegisters +

    Max number of vertex shader constant registers (DX8/9 only). It can only be defined for SVGA and Internal3D card types. Valid values are 256 (default), 512 or 1024. The larger value the larger performance loss.

    +
    • +
  • MSD3DDeviceNames +

    Some application checks against the Microsoft names of D3D devices (bad practice). If none of found then they probably won't work at all. dgVoodoo's device names differ from the Microsoft ones + but enabling this option forces the wrapper to report MS device names. +

    +
    • +
  • RTTexturesForceScaleAndMSAA +

    By default, size of 3D-renderable (rendertarget) textures are internally scaled along with the forced resolution, and also, they inherits the forced MSAA chosen for the rendering. + Rendertarget textures are typically used for pre-rendering reflections, shadows, water and such, but their unexpected size and MSAA type can introduce some unwanted glitches. + If that is the case then you can try disabling this option to have them at their original intended state but this can easily drive dgVoodoo into unresolvable situations producing errors. + The debug layer reports if such a situation is detected and this option is not applicable for the given application. +

    +
    • +
  • SmoothedDepthSampling +

    D3D8 only: by default, depth textures gets some additional filtering when sampling them. Depth textures are typically used for rendering shadows so they are smoothed by default. + Disabling this option leads to simple sampling as it is done in real D3D8, getting more jagged shadows. +

    +
    • +
  • DeferredScreenModeSwitch +

    If true the switching to full screen is deferred after the application initialized + the DirectX device; can be useful for games that don't expect rendering window changes + during initialization and crash +

    +
    • +
  • PrimarySurfaceBatchedUpdate +

    If enabled then direct changes of the primary surface are batched up to present them one time. If disabled then each change is immediately presented (debug-like mode). + It affects only DirectDraw. +

    +
    • +
+ +
+ +

+8. Tips and known issues +

+ +
    +
  • Always try to run an application with 'application controlled fs/windowed state' + and disabled 'Alt-Enter' for the first time. If 'Alt-Enter' is enabled then + the wrapper makes some changes to the application window which can cause some + applications to miswork or even crash.
    • +
  • Also, always try an application without enabling 'Fast video memory access' for + the first time as that method may be unsafe for the application in question, and, + unortunately can cause inappropriate working. +
    • +
  • + Upscaling (forcing resolution) for old 8 bit paletted DDraw applications are not + recommended. Paletted things and forced resolution don't work well together, + but I want to fix it in the future.
    + Upscaling scenes by forcing resolution, where no 3D-rendered objects are presents, + has no sense anyway. +
    • +
  • Forcing vertical retrace is not always a good idea. There are games of which + loaders refreshes the screen at maximum speed (without vertical sync) while + loading textures, meshes, etc. If vSync is forced to on then it can take ages + while it all gets over.
    • +
+ +
+

+ + + 9. Why doesn't dgVoodoo DX emulation start up? + + +

+

+ I got reports about cases with dgVoodoo DirectX emulation not starting up. + The story is simple, one copies the DX dll files into the given application folder, + next to the executable, makes sure that DX emulation is enabled on the CPL, and in + spite of that, when starting the application dgVoodoo isn't utilized at all, dgVoodoo + watermark doesn't show up in the corner if the app starts at all. + Thanks to the Guys on Vogons, who are helping me a lot, they come out with 2 reasons: +

+
    +
  • + Some of the DX dlls (ddraw.dll, d3d8.dll) are registered in the KnownDLLs section of + the Windows registry. When they are then the operating system always loads the system + versions of those dlls. Removing the entries from
    + "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs"
    + is undangerous and can be safely done with Regedit. + This issue causes the majority of the problems. +
    • +
  • + A bit marginal but existing problem with DirectDraw is that it can be initialized through + Windows' OLE mechanism which identifies objects with GUIDs. The 'GUID-dll name' pairs are + also stored in Windows registry but Microsoft switched to absolute dll paths in Windows 8(?) + instead of the relative ones present in Windows 7, so the OLE-accessed DirectDraw is always + the system one in that case. The registry entries in question can be changed back to relative paths, + but since Regedit requires TrustedInstaller privilege level for that, and you have to search for + the entries yourself, it is a complicated process, I don't recommend you to experiment with it. + Luckily most of the old programs access DirectDraw directly, bypassing OLE. +
    • +
+

+ I know that these details are technical like hell, and I don't at all expect an average user to + tinker the operating system registry by hand. I just write this info here because I think it's useful for + advanced users and experts to begin with. A dgVoodoo tool doing it all would be fine but currently doesn't + exist one. +

+

+ But don't forget to try the special release version and see the output log if experiencing any problem with dgVoodoo. +

+ + + + \ No newline at end of file diff --git a/ReadmeGlide.html b/ReadmeGlide.html new file mode 100644 index 0000000..b9585e0 --- /dev/null +++ b/ReadmeGlide.html @@ -0,0 +1,442 @@ + + + + + + + + + + dgVoodoo2 Glide Readme + + + + + + +

+===============================================================================
+dgVoodoo 2.7: Glide related stuffs
+
+===============================================================================
+

+ +

+

+Table of contents +

+

+1. Glide options
+2. Glide additional options
+3. Gamma correction
+4. Some technical info
+5. Napalm build
+6. Tips and known issues
+

 +

+===============================================================================
+ +

+1. Glide options +

+ +
    +
  • 3Dfx card +

    + Selected card type affects the following: +

      +
    • Limits your choice possibilities in respect of 'Onboard RAM', + 'Texture memory' and 'Number of TMUs' according to the + card type. Some applications (like the miniGL driver) + may check for those values and won't work if one of them + is too high. So it is more handy to select a card type + to limit those values alltogether than configuring + one-by-one by heart.
      • +
    • Some exposed capabilites. See techical info for more. + List of different card caps/behaviors may be extended in the future, + according to 3dfx specs.
      • +
    +

    • + +
  • Onboard RAM +

    + Videomemory without texture memory. Some application + compute by this value that what resolutions are supported. +

    +
    • +
  • Resolution/MSAA +

    + You can force the resolution, the refresh rate and MSAA.
    + If the refresh rate is unforced (or enumerating refresh rates is disabled) then the application selected one will be used. + If the application defines a default refresh rate then 60Hz is used instead. +
    + If the chosen refresh rate is unsupported by your monitor at a given resolution then the closest supported one will be selected. +

    + Option 'Application driven' for MSAA has meaning only for + Napalm build. For non-Napalm builds it is equivalent to 'Off'. +

    + +
    • + +
  • Number of TMUs +

    + This version can emulate more than one Texture + Management Units. +

    +
    • + +
  • Texture mem size +

    + Onboard RAM and texture memory are unified video memory on + UMA 3Dfx cards (see table in technical info). Future + versions of the CPL app may not allow to config them + separately. +

    +
    • + +
  • Filtering +

    + You can force the texture filtering to either point sampled or bilinear; or simply leave it at application default. +

    +
    • + +
  • Disable mipmapping +

    + I liked it in some games that looked nicer without mipmapping. :) +

    +
    • + +
  • Enable Glide-gamma ramp +

    + See section "Gamma Correction". +

    +
    • + +
  • Force VSync +

    + Forces at least one vertical retrace before buffer swapping. Use this option if something gets too fast. +

    +
    • + +
  • Force Emulating True PCI Access +

    + see section 'Some techincal info' +

    +
    • + +
  • 16 bit depth buffer +

    + see section 'Tips' +

    +
    • + +
  • 3Dfx Watermark +

    + Enables displaying the 3Dfx logo during the app animation. + You need the 3Dfx splash dlls for this. If they are + missing, no logo will be displayed. +

    +
    • + +
  • 3Dfx Splash screen +

    + Enables splash screen at game/app startup. + You need the 3Dfx splash dlls for this. If they are +

    +
    • + +
  • Pointcast Palette Driver Build +

    + see section 'Some techincal info' +

    +
    • +
  • Enable inactive app state +

    + Glide games/demos can have two bad habits: +

      +
    • Cannot tolerate losing application focus (Alt-Tabbing to another application) and crash or quit.
      • +
    • Do not pump the message queue of their window - it was not a problem on Win95/98 but today's Windows' treat the state of such applications 'Not responding'.
      • +

    + By default, dgVoodoo tries to avoid, and to workaround those cases with some extra work.
    + However it can unfortunately cause other unexpected issues in some games; if it does then you can enable this option instructing dgVoodoo not to intervent. +

    +
    • +
+ + +
+ +

+2. Glide additional options +

+ +
    +
  • Dithering +

      +
    • Disabled: Dithering is always disabled, ending up 16-bit quality rendering
      • +
    • Appdriven: The application can choose between disabling, dithering2x2 and dithering4x4
      • +
    • ForceAlways: Dithering is always enabled and the selected dithering effect is applied (default)
      • +

    • +
  • DitheringEffect +

      +
    • Dither2x2: Ordered dithering with a 2x2 dithering matrix
      • +
    • Dither4x4: Ordered dithering with a 4x4 dithering matrix
      • +
    • Pure32Bit: 32 bit rendering quality (default)
      • +

    • +
  • DitherOrderedMatrixSizeScale - integer scale value for dither matrix size +

      +
    • 1 = normal, 2 = double size, etc.
      • +
    • 0 = automatic (the aim is to have some retro feel&look) (default)
      • +

    • +
+ +
+ +

+3. Gamma correction +

+ +

+A gamma correction curve can be set through the Glide interface. Since Glide +uses a linear curve by default it might not match the default or one's taste +and can look ugly (at least in the old days, I remember it looked ugly on CRTs). +For the standard see sRGB on google. +

+

+That's why the CPL has the 'Enable Glide gammaramp' option: you can disable +the curve coming from Glide and let your monitor use the default. +

+

+*As taking a closer look into this, I realized that a linear curve is used by +the nowadays adapters by default but they probably post-calibrate it according +to the sRGB standard. So Glide's linear curve won't change anything to wrong. +I'm little confused about this. Back in the old days my real problem could be +that either brightness of my CRT was too high by default or sRGB was not +followed by the adapters therefore some gamma-adjusting game had really bad (pale +and really bright) look. I do not know it by now but won't remove the possibility +of disabling Glide gamma ramp. Test it on your monitor. +

+

+Color adjustments are supported in both fullscreen and windowed mode however +brightness is always calculated into the gamma ramp curve in fullscreen so +it has effect only if your adapter supports setting up gamma curves. +

+ +
+ +

+4. Some technical info +

+ +

+Unfortunately Glide cannot be implemented in practice as a standalone API which +is completely independent on the underlying hardware. If someone looks through +the Glide SDK then it is clear that this API is suited for the 3Dfx Voodoo +hardware and its registers. However there are rules even in Glide (as in other +APIs too) that must be observed in respect of driving the API. An application +should never assume anything about the hardware being driven even if it knows +what hardware it is driving. The application should get all the info from the +API and keep the driving rules. +

+

+However in practice there are some application violating those rules very hard. +Since Glide provides free direct access to the frame buffer it is typical to +utilize the properties of a real 3Dfx hardware connected to the PCI bus. For +example, writing to the frame buffer while it was requested to lock for reading, +swapping buffers while one/some of the buffers are locked and assuming that the +mapped pointers of buffers remains unchanged, using 2048 bytes as frame buffer +stride, or drawing simultaneously by the 3D hardware and LFB writes through the +PCI bus even when a buffer was locked with idle 3D hardware mode. +Most of them can be workarounded easily but there is one case which can cause +performance drop if emulated perfectly. This case is the mentioned simultaneous +writing. dgVoodoo can emulate this usecase but you must enable it explicitly so +I reluctantly inserted an option into the CPL, named +'Force emulating true PCI access'. This is the only technical option related to +the quality of the implementation. There are only a few games it should be used +for (see 'Tips') so it would be a pity to have it pointlessly enabled for the +rest. +

+

+There is another strange option in the CPL, namely 'Pointcast Palette driver +build'. Well, early 3Dfx hardware allowed separate texture palettes/ncc tables +for each TMU so this possibility was reflected in Glide 2.11 and 2.43. However, +latter 3Dfx hardware used a unified memory model meaning that only one global +palette/ncc could be set for all the TMUs. Glide3 don't even allow to set them +in any other way. The funny thing is that original Glide2 drivers internally +also forced the global palette/ncc thing despite the API allowed separate ones. +It was because of pushing the programmers towards the future hardware. But, maybe +there were drivers built for custom vendors with the capability of separate +tables. So if this option is enabled in the CPL then such a driver build is +emulated but it has effect only on non-UMA cards. I don't think that any Glide +application in the world requests such a driver build so always keep this option +disabled. It just makes the appearance wrong if more than one TMU are used. +This option is only for the sake of fullness. +

+

+dgVoodoo exposes the following Glide capabilities according to the selected card +type: +

+ + + + + + + + + + +
Card typeFBI revisionTMU revisionGlide3 extensionsUMA
? (unexposable via dgVoodoo)0x00010x0000-no
Voodoo Graphics (SST-1)0x00020x0001GETGAMMAno
Voodoo Rush (SST-96)0x00020x0001GETGAMMA, CHROMARANGEno
Voodoo 20x00020x0001GETGAMMA, CHROMARANGE, TEXMIRROR, PALETTE6666no
Voodoo Banshee0x10020x1001GETGAMMA, CHROMARANGE, TEXMIRROR, PALETTE6666, TEXUMA, TEXTUREBUFFERyes
Other (greater)0x1000030x100002GETGAMMA, CHROMARANGE, TEXMIRROR, PALETTE6666, TEXUMA, TEXTUREBUFFER, FOGCOORD, TEXCHROMA, *PIXEXT, *COMBINE, *TEXFMT, *SURFACE, *GETREGISTRYyes
+ +* Available in Napalm build only + +
+
+

+5. Napalm build +

+ +

+Why is a separate build needed for Napalm? Why not just use it as a plain Glide3 +implementation in general? Well, the answer is about the performance, again. +Napalm has a bit more complicated shaders in order to handle Voodoo4 features +like extended combine modes, 32 bit rendering, 32 bit texture formats and big +textures. So, it would be wasting of GPU resources to use it with Glide3 +applications not requiring these features (that is, all apps except Project64, in +practice :) ). +

+

+Note that there is no significant difference between Glide3 and Glide3 Napalm +as for performance if dynamic shader compiling is enabled. In both cases, much +more optimal shaders are compiled and used than the precompiled ones. +
+Some limitiations: +

+ +
    +

  • Compressed textures (FXT1, DXT*) are not supported. :(

    • +

  • Reading/writing stencil values via 32 bit aux lfb lock won't work.

    • +

  • T-Buffer writemask can only be controlled by the application if antialiasing + mode is set to 'App driven'.

    • +

  • SURFACE and GETREGISTRY extension are only used by the 3Dfx OpenGL 1.1 driver + which is an OpenGL -> (Glide3 Napalm and DirectDraw) wrapper. Since Glide3 + operates on surfaces created by DirectDraw (3Dfx implementation), SURFACE + functionality cannot be implemented. It means that original 3Dfx OpenGL driver + won't work with a standalone Glide3 wrapper (it would make no sense but would + be nice). + Since OpenGL does not work, GETREGISTRY functionality is also needless. So, + those two extensions are only placeholders, bunch of empty functions.

    • +
+ +

+Don't forget to set card type to 'Other (greater)' with 2 TMUs in the CPL to +emulate a Voodoo4. +

+ +
+ +

+6. Tips and known issues +

+ +
    +

  • Forced trilinear texture filtering is not available in this wrapper version + but an application can implement it by 2 drawing passes if one TMU is used. + If more than one TMU are enabled then it can be done by one pass. Since + more TMUs are generally used for drawing the same as with one TMU but with + less passes, enabling multiple TMUs can be useful even if the gpu is loaded + with heavier shader code. It depends. Try out both cases. +

    • +

  • Keep in mind that not all Glide application are usable in windowed mode. Some + of them behave very well while others may not at all. Since they were + designed for an environment with one monitor and exclusive fullscreen display, + an application can get minimized or simply quits when its window loses the + focus. Also, they may capture the mouse into a fix area and you cannot even + move the game window. Or worse: if this fix area is hardcoded and (so) is on + the primary monitor then you can play the game only on the primary monitor even + in fullscreen mode. dgVoodoo tries to workaround these cases by hiding some + events from the application but generally it is not enough. +

    • +

  • DosBox: dgVoodoo works perfectly with Gulikoza's + newest Glide patch. Keep in mind that Extreme Assault needs a 3Dfx card with + non-UMA architecture (see table of exposed caps) and PCI emulation. +

    • +

  • Emulating PCI access is optimized for applications locking and accessing the + LFB very frequently (per frame). Altough it provides faster lfb data access than + doing the normal way, I cannot recommend to use it in general for all apps. + Due to nature of the technique used it can cause slowdown in applications + that access the lfb "regularly", that is, once or twice per frame. + Carmageddon 1, Extreme Assault, Dreams To Reality and Pyl are the only cases + where it has to be used, afaik. +

    • +

  • A strange case: when I tried to run a Glide based scene-demo, TBC, + it always crashed at a certain point due to stack overflow. I had to + manually grow the reserved stack size of the exe file to get it to run. + Probably a real 3Dfx driver required smaller stack than a Direct3D11 + based driver.
    + (http://xona.com/tobecontinued/) +

    • +

  • I ran into a problem with NFS 3 Hot Pursuit: ugly z-fighting which is most + noticable with projected headlights. This game does not use depth bias + but utilize the inaccuracy of the 16 bit voodoo depth buffer when rendering + polygons onto each other (I'm not sure if it was intentional or just a bug). + If an app uses z-buffering then using a 16 bit depth buffer in the emulation + provides the correct and exact mapping of the z values, like on a real Voodoo. + And so NFS3 HP also works well with a 16 bit depth buffer. I was thinking on + how to workaround this problem or automate this mechanism but found no way. + So, reluctantly again, I exposed this into an option in the CPL... + This is the second option related to the quality of the implementation, + aaaarrghh. +

    • +
+ + + + + + \ No newline at end of file