| blob | 143044467f676106f7125ab0c8e0b410dea19bb2 |
1 /*
2 * Copyright 2002-2004 Jason Edmeades
3 * Copyright 2003-2004 Raphael Junqueira
4 * Copyright 2004 Christian Costa
5 * Copyright 2005 Oliver Stieber
6 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
7 * Copyright 2009-2010 Henri Verbeet for CodeWeavers
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
25 #include <stdio.h>
31 #define WINE_DEFAULT_VIDMEM (64 * 1024 * 1024)
33 /* The driver names reflect the lowest GPU supported
34 * by a certain driver, so DRIVER_AMD_R300 supports
35 * R3xx, R4xx and R5xx GPUs. */
36 enum wined3d_display_driver
37 {
38 DRIVER_AMD_RAGE_128PRO,
39 DRIVER_AMD_R100,
40 DRIVER_AMD_R300,
41 DRIVER_AMD_R600,
42 DRIVER_INTEL_GMA800,
43 DRIVER_INTEL_GMA900,
44 DRIVER_INTEL_GMA950,
45 DRIVER_INTEL_GMA3000,
46 DRIVER_NVIDIA_TNT,
47 DRIVER_NVIDIA_GEFORCE2MX,
48 DRIVER_NVIDIA_GEFORCEFX,
49 DRIVER_NVIDIA_GEFORCE6,
50 DRIVER_UNKNOWN
51 };
53 enum wined3d_driver_model
54 {
55 DRIVER_MODEL_WIN9X,
56 DRIVER_MODEL_NT40,
57 DRIVER_MODEL_NT5X,
58 DRIVER_MODEL_NT6X
59 };
61 enum wined3d_gl_vendor
62 {
63 GL_VENDOR_UNKNOWN,
64 GL_VENDOR_APPLE,
65 GL_VENDOR_FGLRX,
66 GL_VENDOR_INTEL,
67 GL_VENDOR_MESA,
68 GL_VENDOR_NVIDIA,
69 };
71 /* The d3d device ID */
72 static const GUID IID_D3DDEVICE_D3DUID = { 0xaeb2cdd4, 0x6e41, 0x43ea, { 0x94,0x1c,0x83,0x61,0xcc,0x76,0x07,0x81 } };
74 /* Extension detection */
75 static const struct
76 {
79 DWORD version;
80 }
81 EXTENSION_MAP[] =
82 {
83 /* APPLE */
91 /* ARB */
135 /* ATI */
142 /* EXT */
175 /* NV */
197 /* SGI */
199 };
201 /**********************************************************
202 * Utility functions follow
203 **********************************************************/
206 {
207 /* NONE POINT LINEAR */
211 };
214 {
215 /* NONE POINT LINEAR */
219 };
222 {
223 /* NONE POINT LINEAR */
227 };
230 {
231 /* NONE POINT LINEAR */
233 };
236 {
237 /* NONE POINT LINEAR */
239 };
241 /* drawStridedSlow attributes */
244 glAttribFunc specular_func_3ubv;
249 /**
250 * Note: GL seems to trap if GetDeviceCaps is called before any HWND's created,
251 * i.e., there is no GL Context - Get a default rendering context to enable the
252 * function query some info from GL.
253 */
255 struct wined3d_fake_gl_ctx
256 {
257 HDC dc;
258 HWND wnd;
259 HGLRC gl_ctx;
260 HDC restore_dc;
261 HGLRC restore_gl_ctx;
262 };
265 {
269 {
271 }
274 {
277 }
283 {
285 }
286 }
288 /* Do not call while under the GL lock. */
290 {
291 PIXELFORMATDESCRIPTOR pfd;
299 /* We need a fake window as a hdc retrieved using GetDC(0) can't be used for much GL purposes. */
303 {
306 }
310 {
313 }
315 /* PixelFormat selection */
319 pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW; /* PFD_GENERIC_ACCELERATED */
326 {
327 /* If this happens something is very wrong as ChoosePixelFormat barely fails. */
330 }
334 /* Create a GL context. */
337 {
340 }
342 /* Make it the current GL context. */
344 {
346 }
349 {
352 }
356 fail:
364 {
366 }
369 }
371 /* Adjust the amount of used texture memory */
373 {
379 }
382 {
385 }
388 {
394 }
397 {
403 {
407 {
409 }
411 }
414 }
416 /* GL locking is done by the caller */
418 {
419 GLuint prog;
424 "ADDRESS A0;"
434 }
439 {
450 }
453 {
458 }
459 }
461 }
463 static BOOL match_amd_r300_to_500(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
464 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
465 {
471 }
474 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
475 {
477 {
481 {
483 }
484 }
486 }
489 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
490 {
491 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
492 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
493 * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
494 *
495 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
496 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
497 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
498 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
499 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
500 * the chance that other implementations support them is rather small since Win32 QuickTime uses
501 * DirectDraw, not OpenGL.
502 *
503 * This test has been moved into wined3d_guess_gl_vendor()
504 */
506 {
508 }
510 }
512 /* Context activation is done by the caller. */
514 {
515 /* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs,
516 * but glTexSubImage from a PBO fails miserably, with the first line repeated over
517 * all the texture. This function detects this bug by its symptom and disables PBOs
518 * if the test fails.
519 *
520 * The test uploads a 4x4 texture via the PBO in the "native" format GL_BGRA,
521 * GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use
522 * for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data
523 * read back is compared to the original. If they are equal PBOs are assumed to work,
524 * otherwise the PBO extension is disabled. */
527 {
532 };
535 /* No PBO -> No point in testing them. */
550 GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, sizeof(pattern), pattern, GL_STREAM_DRAW_ARB));
573 {
577 }
578 else
579 {
581 }
582 }
585 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
586 {
588 }
590 static BOOL match_apple_nonr500ati(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
591 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
592 {
597 }
600 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
601 {
604 }
607 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
608 {
609 /* DX9 cards support 40 single float varyings in hardware, most drivers report 32. ATI misreports
610 * 44 varyings. So assume that if we have more than 44 varyings we have a dx10 card.
611 * This detection is for the gl_ClipPos varying quirk. If a d3d9 card really supports more than 44
612 * varyings and we subtract one in dx9 shaders its not going to hurt us because the dx9 limit is
613 * hardcoded
614 *
615 * dx10 cards usually have 64 varyings */
617 }
619 /* A GL context is provided by the caller */
620 static BOOL match_allows_spec_alpha(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
621 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
622 {
623 GLenum error;
635 {
638 }
639 else
640 {
644 }
645 }
648 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
649 {
652 }
654 /* A GL context is provided by the caller */
655 static BOOL match_broken_nv_clip(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
656 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
657 {
658 GLuint prog;
660 GLint pos;
675 {
679 }
685 {
690 }
699 }
701 /* Context activation is done by the caller. */
702 static BOOL match_fbo_tex_update(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
703 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
704 {
707 GLenum status;
724 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
742 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
754 }
756 /* Context activation is done by the caller. */
758 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
759 {
760 /* GL_RGBA16 uses GL_RGBA8 internally on Geforce 7 and older cards.
761 * This leads to graphical bugs in Half Life 2 and Unreal engine games. */
762 GLuint tex;
763 GLint size;
784 }
787 {
788 TRACE_(d3d_caps)("Using ARB vs constant limit(=%u) for GLSL.\n", gl_info->limits.arb_vs_native_constants);
790 TRACE_(d3d_caps)("Using ARB ps constant limit(=%u) for GLSL.\n", gl_info->limits.arb_ps_native_constants);
792 }
795 {
797 /* MacOS needs uniforms for relative addressing offsets. This can accumulate to quite a few uniforms.
798 * Beyond that the general uniform isn't optimal, so reserve a number of uniforms. 12 vec4's should
799 * allow 48 different offsets or other helper immediate values. */
802 }
804 /* fglrx crashes with a very bad kernel panic if GL_POINT_SPRITE_ARB is set to GL_COORD_REPLACE_ARB
805 * on more than one texture unit. This means that the d3d9 visual point size test will cause a
806 * kernel panic on any machine running fglrx 9.3(latest that supports r300 to r500 cards). This
807 * quirk only enables point sprites on the first texture unit. This keeps point sprites working in
808 * most games, but avoids the crash
809 *
810 * A more sophisticated way would be to find all units that need texture coordinates and enable
811 * point sprites for one if only one is found, and software emulate point sprites in drawStridedSlow
812 * if more than one unit needs texture coordinates(This requires software ffp and vertex shaders though)
813 *
814 * Note that disabling the extension entirely does not gain predictability because there is no point
815 * sprite capability flag in d3d, so the potential rendering bugs are the same if we disable the extension. */
817 {
819 {
822 }
823 }
826 {
829 /* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and earlier cards, although
830 * these cards only support GL_ARB_texture_rectangle(D3DPTEXTURECAPS_NONPOW2CONDITIONAL).
831 * If real NP2 textures are used, the driver falls back to software. We could just remove the
832 * extension and use GL_ARB_texture_rectangle instead, but texture_rectangle is inconventient
833 * due to the non-normalized texture coordinates. Thus set an internal extension flag,
834 * GL_WINE_normalized_texrect, which signals the code that it can use non power of two textures
835 * as per GL_ARB_texture_non_power_of_two, but has to stick to the texture_rectangle limits.
836 *
837 * fglrx doesn't advertise GL_ARB_texture_non_power_of_two, but it advertises opengl 2.0 which
838 * has this extension promoted to core. The extension loading code sets this extension supported
839 * due to that, so this code works on fglrx as well. */
841 {
845 }
847 /* fglrx has the same structural issues as the one described in quirk_apple_glsl_constants, although
848 * it is generally more efficient. Reserve just 8 constants. */
851 }
854 {
855 /* The nVidia GeForceFX series reports OpenGL 2.0 capabilities with the latest drivers versions, but
856 * doesn't explicitly advertise the ARB_tex_npot extension in the GL extension string.
857 * This usually means that ARB_tex_npot is supported in hardware as long as the application is staying
858 * within the limits enforced by the ARB_texture_rectangle extension. This however is not true for the
859 * FX series, which instantly falls back to a slower software path as soon as ARB_tex_npot is used.
860 * We therefore completely remove ARB_tex_npot from the list of supported extensions.
861 *
862 * Note that wine_normalized_texrect can't be used in this case because internally it uses ARB_tex_npot,
863 * triggering the software fallback. There is not much we can do here apart from disabling the
864 * software-emulated extension and reenable ARB_tex_rect (which was previously disabled
865 * in wined3d_adapter_init_gl_caps).
866 * This fixup removes performance problems on both the FX 5900 and FX 5700 (e.g. for framebuffer
867 * post-processing effects in the game "Max Payne 2").
868 * The behaviour can be verified through a simple test app attached in bugreport #14724. */
869 TRACE("GL_ARB_texture_non_power_of_two advertised through OpenGL 2.0 on NV FX card, removing.\n");
872 }
875 {
876 /* The Intel GPUs on MacOS set the .w register of texcoords to 0.0 by default, which causes problems
877 * with fixed function fragment processing. Ideally this flag should be detected with a test shader
878 * and OpenGL feedback mode, but some GL implementations (MacOS ATI at least, probably all MacOS ones)
879 * do not like vertex shaders in feedback mode and return an error, even though it should be valid
880 * according to the spec.
881 *
882 * We don't want to enable this on all cards, as it adds an extra instruction per texcoord used. This
883 * makes the shader slower and eats instruction slots which should be available to the d3d app.
884 *
885 * ATI Radeon HD 2xxx cards on MacOS have the issue. Instead of checking for the buggy cards, blacklist
886 * all radeon cards on Macs and whitelist the good ones. That way we're prepared for the future. If
887 * this workaround is activated on cards that do not need it, it won't break things, just affect
888 * performance negatively. */
891 }
894 {
896 }
899 {
901 }
904 {
907 }
910 {
912 }
915 {
917 }
920 {
922 }
924 struct driver_quirk
925 {
927 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device);
930 };
933 {
934 {
935 match_amd_r300_to_500,
936 quirk_amd_dx9,
937 "AMD GLSL constant and normalized texrect quirk"
938 },
939 /* MacOS advertises more GLSL vertex shader uniforms than supported by the hardware, and if more are
940 * used it falls back to software. While the compiler can detect if the shader uses all declared
941 * uniforms, the optimization fails if the shader uses relative addressing. So any GLSL shader
942 * using relative addressing falls back to software.
943 *
944 * ARB vp gives the correct amount of uniforms, so use it instead of GLSL. */
945 {
946 match_apple,
947 quirk_apple_glsl_constants,
948 "Apple GLSL uniform override"
949 },
950 {
951 match_geforce5,
952 quirk_no_np2,
953 "Geforce 5 NP2 disable"
954 },
955 {
956 match_apple_intel,
957 quirk_texcoord_w,
958 "Init texcoord .w for Apple Intel GPU driver"
959 },
960 {
961 match_apple_nonr500ati,
962 quirk_texcoord_w,
963 "Init texcoord .w for Apple ATI >= r600 GPU driver"
964 },
965 {
966 match_fglrx,
967 quirk_one_point_sprite,
968 "Fglrx point sprite crash workaround"
969 },
970 {
971 match_dx10_capable,
972 quirk_clip_varying,
973 "Reserved varying for gl_ClipPos"
974 },
975 {
976 /* GL_EXT_secondary_color does not allow 4 component secondary colors, but most
977 * GL implementations accept it. The Mac GL is the only implementation known to
978 * reject it.
979 *
980 * If we can pass 4 component specular colors, do it, because (a) we don't have
981 * to screw around with the data, and (b) the D3D fixed function vertex pipeline
982 * passes specular alpha to the pixel shader if any is used. Otherwise the
983 * specular alpha is used to pass the fog coordinate, which we pass to opengl
984 * via GL_EXT_fog_coord.
985 */
986 match_allows_spec_alpha,
987 quirk_allows_specular_alpha,
988 "Allow specular alpha quirk"
989 },
990 {
991 /* The pixel formats provided by GL_NV_texture_shader are broken on OSX
992 * (rdar://5682521).
993 */
994 match_apple_nvts,
995 quirk_apple_nvts,
996 "Apple NV_texture_shader disable"
997 },
998 {
999 match_broken_nv_clip,
1000 quirk_disable_nvvp_clip,
1001 "Apple NV_vertex_program clip bug quirk"
1002 },
1003 {
1004 match_fbo_tex_update,
1005 quirk_fbo_tex_update,
1006 "FBO rebind for attachment updates"
1007 },
1008 {
1009 match_broken_rgba16,
1010 quirk_broken_rgba16,
1011 "True RGBA16 is not available"
1012 },
1013 };
1015 /* Certain applications (Steam) complain if we report an outdated driver version. In general,
1016 * reporting a driver version is moot because we are not the Windows driver, and we have different
1017 * bugs, features, etc.
1018 *
1019 * The driver version has the form "x.y.z.w".
1020 *
1021 * "x" is the Windows version the driver is meant for:
1022 * 4 -> 95/98/NT4
1023 * 5 -> 2000
1024 * 6 -> 2000/XP
1025 * 7 -> Vista
1026 * 8 -> Win 7
1027 *
1028 * "y" is the maximum Direct3D version the driver supports.
1029 * y -> d3d version mapping:
1030 * 11 -> d3d6
1031 * 12 -> d3d7
1032 * 13 -> d3d8
1033 * 14 -> d3d9
1034 * 15 -> d3d10
1035 * 16 -> d3d10.1
1036 * 17 -> d3d11
1037 *
1038 * "z" is the subversion number.
1039 *
1040 * "w" is the vendor specific driver build number.
1041 */
1043 struct driver_version_information
1044 {
1051 };
1053 /* The driver version table contains driver information for different devices on several OS versions. */
1055 {
1056 /* AMD
1057 * - Radeon HD2x00 (R600) and up supported by current drivers.
1058 * - Radeon 9500 (R300) - X1*00 (R5xx) supported up to Catalyst 9.3 (Linux) and 10.2 (XP/Vista/Win7)
1059 * - Radeon 7xxx (R100) - 9250 (RV250) supported up to Catalyst 6.11 (XP)
1060 * - Rage 128 supported up to XP, latest official build 6.13.3279 dated October 2001 */
1068 /* Intel
1069 * The drivers are unified but not all versions support all GPUs. At some point the 2k/xp
1070 * drivers used ialmrnt5.dll for GMA800/GMA900 but at some point the file was renamed to
1071 * igxprd32.dll but the GMA800 driver was never updated. */
1079 /* Nvidia
1080 * - Geforce6 and newer cards are supported by the current driver (197.x) on XP-Win7
1081 * - GeforceFX support is up to 173.x on <= XP
1082 * - Geforce2MX/3/4 up to 96.x on <= XP
1083 * - TNT/Geforce1/2 up to 71.x on <= XP
1084 * All version numbers used below are from the Linux nvidia drivers. */
1090 };
1092 struct gpu_description
1093 {
1099 };
1101 /* The amount of video memory stored in the gpu description table is the minimum amount of video memory
1102 * found on a board containing a specific GPU. */
1104 {
1105 /* Nvidia cards */
1107 {HW_VENDOR_NVIDIA, CARD_NVIDIA_RIVA_TNT2, "NVIDIA RIVA TNT2/TNT2 Pro", DRIVER_NVIDIA_TNT, 32 },
1109 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE2, "NVIDIA GeForce2 GTS/GeForce2 Pro", DRIVER_NVIDIA_TNT, 32 },
1110 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE2_MX, "NVIDIA GeForce2 MX/MX 400", DRIVER_NVIDIA_GEFORCE2MX,32 },
1112 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE4_MX, "NVIDIA GeForce4 MX 460", DRIVER_NVIDIA_GEFORCE2MX,64 },
1113 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE4_TI4200, "NVIDIA GeForce4 Ti 4200", DRIVER_NVIDIA_GEFORCE2MX,64, },
1114 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5200, "NVIDIA GeForce FX 5200", DRIVER_NVIDIA_GEFORCEFX, 64 },
1115 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5600, "NVIDIA GeForce FX 5600", DRIVER_NVIDIA_GEFORCEFX, 128 },
1116 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5800, "NVIDIA GeForce FX 5800", DRIVER_NVIDIA_GEFORCEFX, 256 },
1117 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6200, "NVIDIA GeForce 6200", DRIVER_NVIDIA_GEFORCE6, 64 },
1118 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6600GT, "NVIDIA GeForce 6600 GT", DRIVER_NVIDIA_GEFORCE6, 128 },
1119 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6800, "NVIDIA GeForce 6800", DRIVER_NVIDIA_GEFORCE6, 128 },
1120 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7300, "NVIDIA GeForce Go 7300", DRIVER_NVIDIA_GEFORCE6, 256 },
1121 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7400, "NVIDIA GeForce Go 7400", DRIVER_NVIDIA_GEFORCE6, 256 },
1122 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7600, "NVIDIA GeForce 7600 GT", DRIVER_NVIDIA_GEFORCE6, 256 },
1123 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7800GT, "NVIDIA GeForce 7800 GT", DRIVER_NVIDIA_GEFORCE6, 256 },
1124 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8300GS, "NVIDIA GeForce 8300 GS", DRIVER_NVIDIA_GEFORCE6, 128 },
1125 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8400GS, "NVIDIA GeForce 8400 GS", DRIVER_NVIDIA_GEFORCE6, 128 },
1126 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600GT, "NVIDIA GeForce 8600 GT", DRIVER_NVIDIA_GEFORCE6, 256 },
1127 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600MGT, "NVIDIA GeForce 8600M GT", DRIVER_NVIDIA_GEFORCE6, 512 },
1128 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8800GTS, "NVIDIA GeForce 8800 GTS", DRIVER_NVIDIA_GEFORCE6, 320 },
1129 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8800GTX, "NVIDIA GeForce 8800 GTX", DRIVER_NVIDIA_GEFORCE6, 768 },
1130 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9200, "NVIDIA GeForce 9200", DRIVER_NVIDIA_GEFORCE6, 256 },
1131 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9400GT, "NVIDIA GeForce 9400 GT", DRIVER_NVIDIA_GEFORCE6, 256 },
1132 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9500GT, "NVIDIA GeForce 9500 GT", DRIVER_NVIDIA_GEFORCE6, 256 },
1133 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9600GT, "NVIDIA GeForce 9600 GT", DRIVER_NVIDIA_GEFORCE6, 384 },
1134 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9800GT, "NVIDIA GeForce 9800 GT", DRIVER_NVIDIA_GEFORCE6, 512 },
1135 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_210, "NVIDIA GeForce 210", DRIVER_NVIDIA_GEFORCE6, 512 },
1136 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT220, "NVIDIA GeForce GT 220", DRIVER_NVIDIA_GEFORCE6, 512 },
1137 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT240, "NVIDIA GeForce GT 240", DRIVER_NVIDIA_GEFORCE6, 512 },
1138 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX260, "NVIDIA GeForce GTX 260", DRIVER_NVIDIA_GEFORCE6, 1024},
1139 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX275, "NVIDIA GeForce GTX 275", DRIVER_NVIDIA_GEFORCE6, 896 },
1140 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX280, "NVIDIA GeForce GTX 280", DRIVER_NVIDIA_GEFORCE6, 1024},
1141 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT320M, "NVIDIA GeForce GT 320M", DRIVER_NVIDIA_GEFORCE6, 1024},
1142 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT325M, "NVIDIA GeForce GT 325M", DRIVER_NVIDIA_GEFORCE6, 1024},
1143 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT330, "NVIDIA GeForce GT 330", DRIVER_NVIDIA_GEFORCE6, 1024},
1144 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTS350M, "NVIDIA GeForce GTS 350M", DRIVER_NVIDIA_GEFORCE6, 1024},
1145 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT420, "NVIDIA GeForce GT 420", DRIVER_NVIDIA_GEFORCE6, 2048},
1146 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT430, "NVIDIA GeForce GT 430", DRIVER_NVIDIA_GEFORCE6, 1024},
1147 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT440, "NVIDIA GeForce GT 440", DRIVER_NVIDIA_GEFORCE6, 1024},
1148 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTS450, "NVIDIA GeForce GTS 450", DRIVER_NVIDIA_GEFORCE6, 1024},
1149 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX460, "NVIDIA GeForce GTX 460", DRIVER_NVIDIA_GEFORCE6, 768 },
1150 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX465, "NVIDIA GeForce GTX 465", DRIVER_NVIDIA_GEFORCE6, 1024},
1151 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX470, "NVIDIA GeForce GTX 470", DRIVER_NVIDIA_GEFORCE6, 1280},
1152 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX480, "NVIDIA GeForce GTX 480", DRIVER_NVIDIA_GEFORCE6, 1536},
1153 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX560, "NVIDIA GeForce GTX 560 TI", DRIVER_NVIDIA_GEFORCE6, 1024},
1154 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX570, "NVIDIA GeForce GTX 570", DRIVER_NVIDIA_GEFORCE6, 1280},
1155 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX580, "NVIDIA GeForce GTX 580", DRIVER_NVIDIA_GEFORCE6, 1536},
1157 /* AMD cards */
1162 {HW_VENDOR_AMD, CARD_AMD_RADEON_XPRESS_200M, "ATI RADEON XPRESS 200M Series", DRIVER_AMD_R300, 64 },
1181 /* Intel cards */
1182 {HW_VENDOR_INTEL, CARD_INTEL_I830G, "Intel(R) 82830M Graphics Controller", DRIVER_INTEL_GMA800, 32 },
1183 {HW_VENDOR_INTEL, CARD_INTEL_I855G, "Intel(R) 82852/82855 GM/GME Graphics Controller", DRIVER_INTEL_GMA800, 32 },
1184 {HW_VENDOR_INTEL, CARD_INTEL_I865G, "Intel(R) 82865G Graphics Controller", DRIVER_INTEL_GMA800, 32 },
1185 {HW_VENDOR_INTEL, CARD_INTEL_I915G, "Intel(R) 82915G/GV/910GL Express Chipset Family", DRIVER_INTEL_GMA900, 64 },
1186 {HW_VENDOR_INTEL, CARD_INTEL_I915GM, "Mobile Intel(R) 915GM/GMS,910GML Express Chipset Family", DRIVER_INTEL_GMA900, 64 },
1187 {HW_VENDOR_INTEL, CARD_INTEL_I945GM, "Mobile Intel(R) 945GM Express Chipset Family", DRIVER_INTEL_GMA950, 64 },
1188 {HW_VENDOR_INTEL, CARD_INTEL_X3100, "Mobile Intel(R) 965 Express Chipset Family", DRIVER_INTEL_GMA3000, 128},
1189 {HW_VENDOR_INTEL, CARD_INTEL_GM45, "Mobile Intel(R) GM45 Express Chipset Family", DRIVER_INTEL_GMA3000, 512}
1190 };
1192 static const struct driver_version_information *get_driver_version_info(enum wined3d_display_driver driver,
1194 {
1199 {
1203 {
1208 }
1209 }
1211 }
1215 {
1216 OSVERSIONINFOW os_version;
1217 WORD driver_os_version;
1224 {
1227 }
1231 {
1234 }
1237 /* Set a default amount of video memory (64MB). In general this code isn't used unless the user
1238 * overrides the pci ids to a card which is not in our database. */
1244 {
1248 }
1249 else
1250 {
1253 {
1255 /* If needed we could distinguish between 9x and NT4, but this code won't make
1256 * sense for NT4 since it had no way to obtain this info through DirectDraw 3.0.
1257 */
1269 {
1272 }
1273 else
1274 {
1276 {
1279 }
1282 }
1291 }
1292 }
1294 /* When we reach this stage we always have a vendor or device id (it can be a default one).
1295 * This means that unless the ids are overriden, we will always find a GPU description. */
1297 {
1299 {
1306 }
1307 }
1310 {
1311 TRACE_(d3d_caps)("Overriding amount of video memory with: %d byte\n", wined3d_settings.emulated_textureram);
1313 }
1315 /* Try to obtain driver version information for the current Windows version. This fails in
1316 * some cases:
1317 * - the gpu is not available on the currently selected OS version:
1318 * - Geforce GTX480 on Win98. When running applications in compatibility mode on Windows,
1319 * version information for the current Windows version is returned instead of faked info.
1320 * We do the same and assume the default Windows version to emulate is WinXP.
1321 *
1322 * - Videocard is a Riva TNT but winver is set to win7 (there are no drivers for this beast)
1323 * For now return the XP driver info. Perhaps later on we should return VESA.
1324 *
1325 * - the gpu is not in our database (can happen when the user overrides the vendor_id / device_id)
1326 * This could be an indication that our database is not up to date, so this should be fixed.
1327 */
1330 {
1334 }
1335 else
1336 {
1339 {
1343 }
1344 else
1345 {
1351 FIXME("Unable to find a driver/device info for vendor_id=%#x device_id=%#x for driver_model=%d\n",
1353 }
1354 }
1358 }
1360 /* Context activation is done by the caller. */
1362 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
1363 {
1367 {
1371 }
1373 /* Find out if PBOs work as they are supposed to. */
1375 }
1378 {
1386 if (*ptr++ != '.') ERR_(d3d_caps)("Invalid opengl version string: %s.\n", debugstr_a(gl_version));
1393 }
1395 static enum wined3d_gl_vendor wined3d_guess_gl_vendor(struct wined3d_gl_info *gl_info, const char *gl_vendor_string, const char *gl_renderer)
1396 {
1398 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
1399 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
1400 * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
1401 *
1402 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
1403 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
1404 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
1405 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
1406 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
1407 * the chance that other implementations support them is rather small since Win32 QuickTime uses
1408 * DirectDraw, not OpenGL. */
1422 /* Intel switched from Intel(R) to Intel® recently, so just match Intel. */
1441 }
1443 static enum wined3d_pci_vendor wined3d_guess_card_vendor(const char *gl_vendor_string, const char *gl_renderer)
1444 {
1461 /* Intel switched from Intel(R) to Intel® recently, so just match Intel. */
1471 FIXME_(d3d_caps)("Received unrecognized GL_VENDOR %s. Returning HW_VENDOR_NVIDIA.\n", debugstr_a(gl_vendor_string));
1474 }
1477 {
1496 }
1498 static enum wined3d_pci_device select_card_nvidia_binary(const struct wined3d_gl_info *gl_info,
1500 {
1505 {
1506 static const struct
1507 {
1510 }
1511 cards[] =
1512 {
1564 };
1567 {
1570 }
1572 /* Geforce8-compatible fall back if the GPU is not in the list yet */
1574 }
1576 /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
1577 * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
1578 */
1580 {
1581 static const struct
1582 {
1585 }
1586 cards[] =
1587 {
1601 };
1604 {
1607 }
1609 /* Geforce 6/7 - lowend */
1611 }
1614 {
1615 /* GeforceFX - highend */
1620 {
1622 }
1624 /* GeforceFX - midend */
1629 {
1631 }
1633 /* GeforceFX - lowend */
1635 }
1638 {
1640 {
1642 }
1645 }
1648 {
1650 {
1652 }
1655 {
1657 }
1660 {
1662 }
1665 }
1668 {
1670 }
1673 }
1677 {
1680 /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1681 *
1682 * Beware: renderer string do not match exact card model,
1683 * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1685 {
1688 static const struct
1689 {
1692 }
1693 cards[] =
1694 {
1695 /* Evergreen */
1706 /* R700 */
1719 /* R600/R700 integrated */
1723 /* R600 */
1737 };
1740 {
1743 }
1745 /* Default for when no GPU has been found */
1747 }
1750 {
1751 /* Radeon R5xx */
1757 {
1759 }
1761 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300/X2500/HD2300 (lowend R5xx)
1762 * Note X2300/X2500/HD2300 are R5xx GPUs with a 2xxx naming but they are still DX9-only */
1773 )
1774 {
1776 }
1778 /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1780 {
1782 }
1784 /* Radeon R3xx */
1786 }
1795 }
1799 {
1802 {
1803 /* MacOS calls the card GMA X3100, otherwise known as GM965/GL960 */
1805 }
1808 {
1809 /* MacOS calls the card GMA 950, but everywhere else the PCI ID is named 945GM */
1811 }
1820 }
1824 {
1825 UINT d3d_level;
1828 /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1829 *
1830 * Beware: renderer string do not match exact card model,
1831 * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1833 {
1834 /* 20101109 - These are never returned by current Gallium radeon
1835 * drivers: R700, RV790, R680, RV535, RV516, R410, RS485, RV360, RV351.
1836 *
1837 * These are returned but not handled: RC410, RV380. */
1838 static const struct
1839 {
1842 }
1843 cards[] =
1844 {
1845 /* Northern Islands */
1849 /* Evergreen */
1855 /* R700 */
1862 /* R600/R700 integrated */
1865 /* R600 */
1873 /* R500 */
1882 /* R400 */
1890 /* Radeon Xpress - onboard, DX9b, Shader 2.0, 300-400MHz */
1898 /* R300 */
1906 };
1909 {
1912 }
1913 }
1917 {
1918 static const struct
1919 {
1922 }
1923 cards[] =
1924 {
1925 /* R700 */
1932 /* R600/R700 integrated */
1935 /* R600 */
1943 };
1946 {
1949 }
1950 }
1959 }
1963 {
1964 UINT d3d_level;
1967 {
1970 static const struct
1971 {
1974 }
1975 cards[] =
1976 {
2031 };
2034 {
2037 }
2038 }
2052 }
2055 struct vendor_card_selection
2056 {
2060 enum wined3d_pci_device (*select_card)(const struct wined3d_gl_info *gl_info, const char *gl_renderer);
2061 };
2064 {
2066 {GL_VENDOR_APPLE, HW_VENDOR_NVIDIA, "Apple OSX NVidia binary driver", select_card_nvidia_binary},
2074 };
2077 static enum wined3d_pci_device wined3d_guess_card(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
2079 {
2080 UINT d3d_level;
2082 /* Above is a list of Nvidia and ATI GPUs. Both vendors have dozens of
2083 * different GPUs with roughly the same features. In most cases GPUs from a
2084 * certain family differ in clockspeeds, the amount of video memory and the
2085 * number of shader pipelines.
2086 *
2087 * A Direct3D device object contains the PCI id (vendor + device) of the
2088 * videocard which is used for rendering. Various applications use this
2089 * information to get a rough estimation of the features of the card and
2090 * some might use it for enabling 3d effects only on certain types of
2091 * videocards. In some cases games might even use it to work around bugs
2092 * which happen on certain videocards/driver combinations. The problem is
2093 * that OpenGL only exposes a rendering string containing the name of the
2094 * videocard and not the PCI id.
2095 *
2096 * Various games depend on the PCI id, so somehow we need to provide one.
2097 * A simple option is to parse the renderer string and translate this to
2098 * the right PCI id. This is a lot of work because there are more than 200
2099 * GPUs just for Nvidia. Various cards share the same renderer string, so
2100 * the amount of code might be 'small' but there are quite a number of
2101 * exceptions which would make this a pain to maintain. Another way would
2102 * be to query the PCI id from the operating system (assuming this is the
2103 * videocard which is used for rendering which is not always the case).
2104 * This would work but it is not very portable. Second it would not work
2105 * well in, let's say, a remote X situation in which the amount of 3d
2106 * features which can be used is limited.
2107 *
2108 * As said most games only use the PCI id to get an indication of the
2109 * capabilities of the card. It doesn't really matter if the given id is
2110 * the correct one if we return the id of a card with similar 3d features.
2111 *
2112 * The code below checks the OpenGL capabilities of a videocard and matches
2113 * that to a certain level of Direct3D functionality. Once a card passes
2114 * the Direct3D9 check, we know that the card (in case of Nvidia) is at
2115 * least a GeforceFX. To give a better estimate we do a basic check on the
2116 * renderer string but if that won't pass we return a default card. This
2117 * way is better than maintaining a full card database as even without a
2118 * full database we can return a card with similar features. Second the
2119 * size of the database can be made quite small because when you know what
2120 * type of 3d functionality a card has, you know to which GPU family the
2121 * GPU must belong. Because of this you only have to check a small part of
2122 * the renderer string to distinguishes between different models from that
2123 * family.
2124 *
2125 * The code also selects a default amount of video memory which we will
2126 * use for an estimation of the amount of free texture memory. In case of
2127 * real D3D the amount of texture memory includes video memory and system
2128 * memory (to be specific AGP memory or in case of PCIE TurboCache /
2129 * HyperMemory). We don't know how much system memory can be addressed by
2130 * the system but we can make a reasonable estimation about the amount of
2131 * video memory. If the value is slightly wrong it doesn't matter as we
2132 * didn't include AGP-like memory which makes the amount of addressable
2133 * memory higher and second OpenGL isn't that critical it moves to system
2134 * memory behind our backs if really needed. Note that the amount of video
2135 * memory can be overruled using a registry setting. */
2140 {
2146 }
2151 /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
2152 * for Nvidia was because the hardware and drivers they make are of good quality. This makes
2153 * them a good generic choice. */
2165 }
2167 static const struct fragment_pipeline *select_fragment_implementation(struct wined3d_adapter *adapter)
2168 {
2180 }
2182 static const struct wined3d_shader_backend_ops *select_shader_backend(struct wined3d_adapter *adapter)
2183 {
2187 if (vs_selected_mode == SHADER_GLSL || ps_selected_mode == SHADER_GLSL) return &glsl_shader_backend;
2188 if (vs_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_ARB) return &arb_program_shader_backend;
2190 }
2193 {
2201 }
2204 {
2205 DWORD ver;
2207 #define USE_GL_FUNC(type, pfn, ext, replace) \
2208 if (gl_info->supported[ext]) gl_info->pfn = (type)pwglGetProcAddress(#pfn); \
2209 else if ((ver = ver_for_ext(ext)) && ver <= gl_version) gl_info->pfn = (type)pwglGetProcAddress(#replace); \
2210 else gl_info->pfn = NULL;
2212 GL_EXT_FUNCS_GEN;
2213 #undef USE_GL_FUNC
2215 #define USE_GL_FUNC(type, pfn, ext, replace) gl_info->pfn = (type)pwglGetProcAddress(#pfn);
2216 WGL_EXT_FUNCS_GEN;
2217 #undef USE_GL_FUNC
2218 }
2220 /* Context activation is done by the caller. */
2222 {
2232 GLint gl_max;
2235 HDC hdc;
2236 DWORD gl_version;
2246 {
2250 }
2255 {
2259 }
2261 /* Parse the GL_VERSION field into major and minor information */
2265 {
2269 }
2272 /*
2273 * Initialize openGL extension related variables
2274 * with Default values
2275 */
2282 gl_info->limits.combined_samplers = gl_info->limits.fragment_samplers + gl_info->limits.vertex_samplers;
2295 /* Retrieve opengl defaults */
2313 /* Parse the gl supported features, in theory enabling parts of our code appropriately. */
2316 {
2320 }
2329 {
2342 {
2345 {
2349 }
2350 }
2351 }
2353 /* Now work out what GL support this card really has */
2358 /* Now mark all the extensions supported which are included in the opengl core version. Do this *after*
2359 * loading the functions, otherwise the code above will load the extension entry points instead of the
2360 * core functions, which may not work. */
2362 {
2365 {
2368 }
2369 }
2374 {
2375 /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
2376 * The apple extension interacts with some other apple exts. Disable the NV
2377 * extension if the apple one is support to prevent confusion in other parts
2378 * of the code. */
2380 }
2382 {
2383 /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
2384 *
2385 * The enums are the same:
2386 * GL_RGBA16F_ARB = GL_RGBA_FLOAT16_APPLE = 0x881A
2387 * GL_RGB16F_ARB = GL_RGB_FLOAT16_APPLE = 0x881B
2388 * GL_RGBA32F_ARB = GL_RGBA_FLOAT32_APPLE = 0x8814
2389 * GL_RGB32F_ARB = GL_RGB_FLOAT32_APPLE = 0x8815
2390 * GL_HALF_FLOAT_ARB = GL_HALF_APPLE = 0x140B
2391 */
2393 {
2396 }
2398 {
2401 }
2402 }
2404 {
2405 /* GL_ARB_map_buffer_range and GL_APPLE_flush_buffer_range provide the same
2406 * functionality. Prefer the ARB extension */
2408 }
2410 {
2413 }
2415 {
2418 }
2420 {
2423 }
2424 if (!gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] && gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC])
2425 {
2426 TRACE_(d3d_caps)(" IMPLIED: ARB_texture_compression_rgtc support (by EXT_texture_compression_rgtc).\n");
2428 }
2430 {
2432 {
2433 /* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2
2434 * are supported. The nv extensions provide the same functionality as the
2435 * ATI one, and a bit more(signed pixelformats). */
2437 }
2438 }
2441 {
2445 }
2447 {
2451 }
2453 {
2459 {
2460 GLint tmp;
2463 }
2464 else
2465 {
2467 }
2471 {
2472 GLint tmp;
2478 /* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup
2479 * is known at shader link time. In a vertex shader + pixel shader combination this isn't
2480 * an issue because then the sampler setup only depends on the two shaders. If a pixel
2481 * shader is used with fixed function vertex processing we're fine too because fixed function
2482 * vertex processing doesn't use any samplers. If fixed function fragment processing is
2483 * used we have to make sure that all vertex sampler setups are valid together with all
2484 * possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES
2485 * <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards).
2486 * dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and
2487 * dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have
2488 * a fixed function pipeline anymore.
2489 *
2490 * So this is just a check to check that our assumption holds true. If not, write a warning
2491 * and reduce the number of vertex samplers or probably disable vertex texture fetch. */
2494 {
2500 else
2502 }
2503 }
2504 else
2505 {
2507 }
2510 }
2512 {
2516 }
2518 {
2522 }
2524 {
2528 }
2530 {
2531 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2533 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM float constants: %d.\n", gl_info->limits.arb_ps_float_constants);
2534 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
2538 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
2540 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_ps_temps);
2541 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
2543 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native instructions: %d.\n", gl_info->limits.arb_ps_instructions);
2544 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, &gl_max));
2546 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM local parameters: %d.\n", gl_info->limits.arb_ps_instructions);
2547 }
2549 {
2550 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2552 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM float constants: %d.\n", gl_info->limits.arb_vs_float_constants);
2553 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
2557 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
2559 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_vs_temps);
2560 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
2562 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native instructions: %d.\n", gl_info->limits.arb_vs_instructions);
2565 }
2567 {
2570 TRACE_(d3d_caps)("Max ARB_VERTEX_SHADER float constants: %u.\n", gl_info->limits.glsl_vs_float_constants);
2571 }
2573 {
2576 TRACE_(d3d_caps)("Max ARB_FRAGMENT_SHADER float constants: %u.\n", gl_info->limits.glsl_ps_float_constants);
2580 }
2582 {
2588 /* The format of the GLSL version string is "major.minor[.release] [vendor info]". */
2591 }
2593 {
2595 }
2596 else
2597 {
2599 }
2601 {
2602 /* If we have full NP2 texture support, disable
2603 * GL_ARB_texture_rectangle because we will never use it.
2604 * This saves a few redundant glDisable calls. */
2606 }
2608 {
2609 /* Disable NV_register_combiners and fragment shader if this is supported.
2610 * generally the NV extensions are preferred over the ATI ones, and this
2611 * extension is disabled if register_combiners and texture_shader2 are both
2612 * supported. So we reach this place only if we have incomplete NV dxlevel 8
2613 * fragment processing support. */
2618 }
2620 {
2621 /* GL_ARB_half_float_vertex is a subset of GL_NV_half_float. */
2623 }
2625 {
2627 }
2628 else
2629 {
2631 }
2644 /* In some cases the number of texture stages can be larger than the number
2645 * of samplers. The GF4 for example can use only 2 samplers (no fragment
2646 * shaders), but 8 texture stages (register combiners). */
2647 gl_info->limits.sampler_stages = max(gl_info->limits.fragment_samplers, gl_info->limits.texture_stages);
2650 {
2667 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv = gl_info->glGetFramebufferAttachmentParameteriv;
2670 }
2671 else
2672 {
2674 {
2690 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv = gl_info->glGetFramebufferAttachmentParameterivEXT;
2692 }
2694 {
2695 WARN_(d3d_caps)("Framebuffer objects not supported, falling back to backbuffer offscreen rendering mode.\n");
2697 }
2699 {
2701 }
2703 {
2704 gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->glRenderbufferStorageMultisampleEXT;
2705 }
2706 }
2708 /* MRTs are currently only supported when FBOs are used. */
2710 {
2712 }
2716 TRACE_(d3d_caps)("found GL_VENDOR (%s)->(0x%04x/0x%04x)\n", debugstr_a(gl_vendor_str), gl_vendor, card_vendor);
2719 TRACE_(d3d_caps)("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", card_vendor, device);
2730 /* Make sure there's an active HDC else the WGL extensions will fail */
2733 /* Not all GL drivers might offer WGL extensions e.g. VirtualBox */
2738 {
2740 }
2741 else
2742 {
2745 {
2764 }
2768 }
2772 }
2773 }
2774 }
2775 }
2782 }
2785 {
2790 }
2793 {
2797 }
2800 {
2806 return MonitorFromPoint(wined3d->adapters[adapter_idx].monitorPoint, MONITOR_DEFAULTTOPRIMARY);
2807 }
2809 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
2810 of the same bpp but different resolutions */
2812 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2815 {
2816 TRACE_(d3d_caps)("wined3d %p, adapter_idx %u, format %s.\n", wined3d, adapter_idx, debug_d3dformat(format_id));
2821 /* TODO: Store modes per adapter and read it from the adapter structure */
2823 {
2824 const struct wined3d_format *format = wined3d_get_format(&wined3d->adapters[adapter_idx].gl_info, format_id);
2828 DEVMODEW mode;
2834 {
2838 {
2839 /* This is for D3D8, do not enumerate P8 here */
2841 }
2843 {
2845 }
2846 }
2848 TRACE_(d3d_caps)("Returning %u matching modes (out of %u total) for adapter %u.\n", i, j, adapter_idx);
2851 }
2852 else
2853 {
2855 }
2858 }
2860 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2863 {
2867 /* Validate the parameters as much as possible */
2870 {
2872 }
2874 /* TODO: Store modes per adapter and read it from the adapter structure */
2876 {
2877 const struct wined3d_format *format = wined3d_get_format(&wined3d->adapters[adapter_idx].gl_info, format_id);
2879 DEVMODEW DevModeW;
2887 /* If we are filtering to a specific format (D3D9), then need to skip
2888 all unrelated modes, but if mode is irrelevant (D3D8), then we can
2889 just count through the ones with valid bit depths */
2891 {
2893 {
2894 /* This is for D3D8, do not enumerate P8 here */
2896 }
2898 {
2900 }
2901 }
2904 {
2905 TRACE_(d3d_caps)("No modes found for format (%x - %s)\n", format_id, debug_d3dformat(format_id));
2907 }
2910 /* Now get the display mode via the calculated index */
2912 {
2921 else
2923 }
2924 else
2925 {
2928 }
2933 }
2934 else
2935 {
2937 }
2940 }
2942 HRESULT CDECL wined3d_get_adapter_display_mode(const struct wined3d *wined3d, UINT adapter_idx,
2944 {
2951 {
2952 DEVMODEW DevModeW;
2966 }
2967 else
2968 {
2970 }
2975 }
2977 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
2978 and fields being inserted in the middle, a new structure is used in place */
2981 {
2993 /* Return the information requested */
2997 {
3002 }
3005 {
3010 }
3012 /* Note that d3d8 doesn't supply a device name. */
3014 {
3019 {
3022 }
3026 }
3034 memcpy(&identifier->device_identifier, &IID_D3DDEVICE_D3DUID, sizeof(identifier->device_identifier));
3040 }
3044 {
3047 /* Float formats need FBOs. If FBOs are used this function isn't called */
3052 {
3055 }
3070 }
3072 /* Probably a RGBA_float or color index mode */
3074 }
3078 {
3083 {
3086 }
3088 /* Float formats need FBOs. If FBOs are used this function isn't called */
3094 /* On some modern cards like the Geforce8/9 GLX doesn't offer some dephthstencil formats which D3D9 reports.
3095 * We can safely report 'compatible' formats (e.g. D24 can be used for D16) as long as we aren't dealing with
3096 * a lockable format. This also helps D3D <= 7 as they expect D16 which isn't offered without this on Geforce8 cards. */
3100 /* Some cards like Intel i915 ones only offer D24S8 but lots of games also need a format without stencil, so
3101 * allow more stencil bits than requested. */
3106 }
3110 enum wined3d_format_id render_target_format_id, enum wined3d_format_id depth_stencil_format_id)
3111 {
3128 {
3131 {
3134 }
3135 }
3136 else
3137 {
3145 {
3148 {
3151 }
3152 }
3153 }
3160 }
3162 HRESULT CDECL wined3d_check_device_multisample_type(const struct wined3d *wined3d, UINT adapter_idx,
3165 {
3177 /* TODO: Handle windowed, add more quality levels. */
3180 {
3183 }
3185 /* By default multisampling is disabled right now as it causes issues
3186 * on some Nvidia driver versions and it doesn't work well in combination
3187 * with FBOs yet. */
3196 {
3203 {
3216 }
3217 }
3219 {
3225 {
3229 }
3234 {
3243 /* Not all drivers report alpha-less formats since they use 32-bit
3244 * anyway, so accept alpha even if we didn't ask for it. */
3256 }
3257 }
3259 }
3261 /* Check if we support bumpmapping for a format */
3262 static BOOL CheckBumpMapCapability(const struct wined3d_adapter *adapter, const struct wined3d_format *format)
3263 {
3264 /* Ask the fixed function pipeline implementation if it can deal
3265 * with the conversion. If we've got a GL extension giving native
3266 * support this will be an identity conversion. */
3269 }
3271 /* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */
3274 {
3277 /* Only allow depth/stencil formats */
3281 {
3282 /* With FBOs WGL limitations do not apply, but the format needs to be FBO attachable */
3284 }
3285 else
3286 {
3287 /* Walk through all WGL pixel formats to find a match */
3289 {
3294 }
3295 }
3298 }
3300 static BOOL CheckFilterCapability(const struct wined3d_adapter *adapter, const struct wined3d_format *format)
3301 {
3302 /* The flags entry of a format contains the filtering capability */
3306 }
3308 /* Check the render target capabilities of a format */
3311 {
3312 /* Filter out non-RT formats */
3315 {
3321 getColorBits(adapter_format, &AdapterRed, &AdapterGreen, &AdapterBlue, &AdapterAlpha, &AdapterTotalSize);
3324 /* In backbuffer mode the front and backbuffer share the same WGL pixelformat.
3325 * The format must match in RGB, alpha is allowed to be different. (Only the backbuffer can have alpha) */
3326 if(!((AdapterRed == CheckRed) && (AdapterGreen == CheckGreen) && (AdapterBlue == CheckBlue))) {
3329 }
3331 /* Check if there is a WGL pixel format matching the requirements, the format should also be window
3332 * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
3334 {
3337 {
3341 }
3342 }
3343 }
3345 {
3346 /* For now return TRUE for FBOs until we have some proper checks.
3347 * Note that this function will only be called when the format is around for texturing. */
3349 }
3351 }
3353 static BOOL CheckSrgbReadCapability(const struct wined3d_adapter *adapter, const struct wined3d_format *format)
3354 {
3356 }
3358 static BOOL CheckSrgbWriteCapability(const struct wined3d_adapter *adapter, const struct wined3d_format *format)
3359 {
3360 /* Only offer SRGB writing on X8R8G8B8/A8R8G8B8 when we use ARB or GLSL shaders as we are
3361 * doing the color fixup in shaders.
3362 * Note Windows drivers (at least on the Geforce 8800) also offer this on R5G6B5. */
3364 {
3372 }
3373 }
3375 TRACE_(d3d_caps)("[FAILED] - sRGB writes not supported by format %s.\n", debug_d3dformat(format->id));
3377 }
3379 /* Check if a format support blending in combination with pixel shaders */
3382 {
3383 /* The flags entry of a format contains the post pixel shader blending capability */
3387 }
3389 static BOOL CheckWrapAndMipCapability(const struct wined3d_adapter *adapter, const struct wined3d_format *format)
3390 {
3391 /* OpenGL supports mipmapping on all formats basically. Wrapping is unsupported,
3392 * but we have to report mipmapping so we cannot reject this flag. Tests show that
3393 * windows reports WRAPANDMIP on unfilterable surfaces as well, apparently to show
3394 * that wrapping is supported. The lack of filtering will sort out the mipmapping
3395 * capability anyway.
3396 *
3397 * For now lets report this on all formats, but in the future we may want to
3398 * restrict it to some should games need that
3399 */
3401 }
3403 /* Check if a texture format is supported on the given adapter */
3404 static BOOL CheckTextureCapability(const struct wined3d_adapter *adapter, const struct wined3d_format *format)
3405 {
3409 {
3410 /*****
3411 * supported: RGB(A) formats
3412 */
3434 /*****
3435 * Not supported: Palettized
3436 * Only some Geforce/Voodoo3/G400 cards offer 8-bit textures in case of <=Direct3D7.
3437 * Since it is not widely available, don't offer it. Further no Windows driver offers
3438 * WINED3DFMT_P8_UINT_A8_NORM, so don't offer it either.
3439 */
3444 /*****
3445 * Supported: (Alpha)-Luminance
3446 */
3453 /* Not supported on Windows, thus disabled */
3458 /*****
3459 * Supported: Depth/Stencil formats
3460 */
3478 /*****
3479 * Not supported everywhere(depends on GL_ATI_envmap_bumpmap or
3480 * GL_NV_texture_shader). Emulated by shaders
3481 */
3487 /* Ask the shader backend if it can deal with the conversion. If
3488 * we've got a GL extension giving native support this will be an
3489 * identity conversion. */
3491 {
3494 }
3504 {
3507 }
3512 /*****
3513 * Odd formats - not supported
3514 */
3526 /*****
3527 * WINED3DFMT_R8G8_SNORM_Cx: Not supported right now
3528 */
3533 /* YUV formats */
3537 {
3540 }
3549 {
3552 }
3556 /* Not supported */
3561 /* Floating point formats */
3566 {
3569 }
3577 {
3580 }
3584 /* ATI instancing hack: Although ATI cards do not support Shader Model 3.0, they support
3585 * instancing. To query if the card supports instancing CheckDeviceFormat with the special format
3586 * MAKEFOURCC('I','N','S','T') is used. Should a (broken) app check for this provide a proper return value.
3587 * We can do instancing with all shader versions, but we need vertex shaders.
3588 *
3589 * Additionally applications have to set the D3DRS_POINTSIZE render state to MAKEFOURCC('I','N','S','T') once
3590 * to enable instancing. WineD3D doesn't need that and just ignores it.
3591 *
3592 * With Shader Model 3.0 capable cards Instancing 'just works' in Windows.
3593 */
3597 {
3600 }
3604 /* Some weird FOURCC formats */
3611 /* Vendor specific formats */
3615 {
3618 {
3621 }
3625 }
3629 /* Depth bound test. To query if the card supports it CheckDeviceFormat with the special
3630 * format MAKEFOURCC('N','V','D','B') is used.
3631 * It is enabled by setting D3DRS_ADAPTIVETESS_X render state to MAKEFOURCC('N','V','D','B') and
3632 * then controlled by setting D3DRS_ADAPTIVETESS_Z (zMin) and D3DRS_ADAPTIVETESS_W (zMax)
3633 * to test value.
3634 */
3637 {
3640 }
3646 /* These formats seem to be similar to the HILO formats in GL_NV_texture_shader. NVHU
3647 * is said to be GL_UNSIGNED_HILO16, NVHS GL_SIGNED_HILO16. Rumours say that d3d computes
3648 * a 3rd channel similarly to D3DFMT_CxV8U8(So NVHS could be called D3DFMT_CxV16U16).
3649 * ATI refused to support formats which can easilly be emulated with pixel shaders, so
3650 * Applications have to deal with not having NVHS and NVHU.
3651 */
3666 }
3668 }
3673 WINED3DSURFTYPE SurfaceType)
3674 {
3676 {
3678 {
3702 }
3703 }
3705 /* All format that are supported for textures are supported for surfaces as well */
3707 /* All depth stencil formats are supported on surfaces */
3710 /* If opengl can't process the format natively, the blitter may be able to convert it */
3714 {
3717 }
3719 /* Reject other formats */
3722 }
3726 {
3728 }
3732 WINED3DRESOURCETYPE resource_type, enum wined3d_format_id check_format_id, WINED3DSURFTYPE surface_type)
3733 {
3740 TRACE_(d3d_caps)("wined3d %p, adapter_idx %u, device_type %s, adapter_format %s, usage %s, %s,\n"
3750 {
3752 /* Cubetexture allows:
3753 * - WINED3DUSAGE_AUTOGENMIPMAP
3754 * - WINED3DUSAGE_DEPTHSTENCIL
3755 * - WINED3DUSAGE_DYNAMIC
3756 * - WINED3DUSAGE_NONSECURE (d3d9ex)
3757 * - WINED3DUSAGE_RENDERTARGET
3758 * - WINED3DUSAGE_SOFTWAREPROCESSING
3759 * - WINED3DUSAGE_QUERY_WRAPANDMIP
3760 */
3762 {
3765 }
3768 {
3771 }
3774 {
3777 }
3780 {
3782 /* When autogenmipmap isn't around continue and return
3783 * WINED3DOK_NOAUTOGEN instead of D3D_OK. */
3785 else
3787 }
3789 /* Always report dynamic locking. */
3794 {
3796 {
3799 }
3801 }
3803 /* Always report software processing. */
3808 {
3810 {
3813 }
3815 }
3818 {
3820 {
3823 }
3825 }
3828 {
3830 {
3833 }
3835 }
3838 {
3840 {
3843 }
3845 }
3848 {
3850 {
3853 }
3855 }
3858 {
3860 {
3863 }
3865 }
3869 /* Surface allows:
3870 * - WINED3DUSAGE_DEPTHSTENCIL
3871 * - WINED3DUSAGE_NONSECURE (d3d9ex)
3872 * - WINED3DUSAGE_RENDERTARGET
3873 */
3875 {
3878 }
3881 {
3883 {
3886 }
3888 }
3891 {
3893 {
3896 }
3898 }
3901 {
3903 {
3906 }
3908 }
3912 /* Texture allows:
3913 * - WINED3DUSAGE_AUTOGENMIPMAP
3914 * - WINED3DUSAGE_DEPTHSTENCIL
3915 * - WINED3DUSAGE_DMAP
3916 * - WINED3DUSAGE_DYNAMIC
3917 * - WINED3DUSAGE_NONSECURE (d3d9ex)
3918 * - WINED3DUSAGE_RENDERTARGET
3919 * - WINED3DUSAGE_SOFTWAREPROCESSING
3920 * - WINED3DUSAGE_TEXTAPI (d3d9ex)
3921 * - WINED3DUSAGE_QUERY_WRAPANDMIP
3922 */
3924 {
3927 }
3930 {
3933 }
3936 {
3938 /* When autogenmipmap isn't around continue and return
3939 * WINED3DOK_NOAUTOGEN instead of D3D_OK. */
3941 else
3943 }
3945 /* Always report dynamic locking. */
3950 {
3952 {
3955 }
3957 }
3959 /* Always report software processing. */
3964 {
3966 {
3969 }
3971 }
3974 {
3976 {
3979 }
3981 }
3984 {
3986 {
3989 }
3991 }
3994 {
3996 {
3999 }
4001 }
4004 {
4006 {
4009 }
4011 }
4014 {
4016 {
4019 }
4021 }
4024 {
4026 {
4029 }
4031 }
4034 {
4036 {
4039 }
4041 {
4044 }
4046 }
4051 /* Volume is to VolumeTexture what Surface is to Texture, but its
4052 * usage caps are not documented. Most driver seem to offer
4053 * (nearly) the same on Volume and VolumeTexture, so do that too.
4054 *
4055 * Volumetexture allows:
4056 * - D3DUSAGE_DYNAMIC
4057 * - D3DUSAGE_NONSECURE (d3d9ex)
4058 * - D3DUSAGE_SOFTWAREPROCESSING
4059 * - D3DUSAGE_QUERY_WRAPANDMIP
4060 */
4062 {
4065 }
4068 {
4071 }
4074 {
4077 }
4079 /* Filter formats that need conversion; For one part, this
4080 * conversion is unimplemented, and volume textures are huge, so
4081 * it would be a big performance hit. Unless we hit an application
4082 * needing one of those formats, don't advertize them to avoid
4083 * leading applications into temptation. The windows drivers don't
4084 * support most of those formats on volumes anyway, except for
4085 * WINED3DFMT_R32_FLOAT. */
4087 {
4101 {
4104 }
4109 {
4112 }
4120 /* The GL_EXT_texture_compression_s3tc spec requires that
4121 * loading an s3tc compressed texture results in an error.
4122 * While the D3D refrast does support s3tc volumes, at
4123 * least the nvidia windows driver does not, so we're free
4124 * not to support this format. */
4129 /* Do nothing, continue with checking the format below */
4131 }
4133 /* Always report dynamic locking. */
4137 /* Always report software processing. */
4142 {
4144 {
4147 }
4149 }
4152 {
4154 {
4157 }
4159 }
4162 {
4164 {
4167 }
4169 }
4172 {
4174 {
4177 }
4179 }
4182 {
4184 {
4187 }
4189 }
4192 {
4194 {
4197 }
4199 }
4205 }
4207 /* When the usage_caps exactly matches usage return WINED3D_OK except for
4208 * the situation in which WINED3DUSAGE_AUTOGENMIPMAP isn't around, then
4209 * WINED3DOK_NOAUTOGEN is returned if all the other usage flags match. */
4215 TRACE_(d3d_caps)("[FAILED] - Usage %#x requested for format %s and resource_type %s but only %#x is available.\n",
4219 }
4221 HRESULT CDECL wined3d_check_device_format_conversion(const struct wined3d *wined3d, UINT adapter_idx,
4222 WINED3DDEVTYPE device_type, enum wined3d_format_id src_format, enum wined3d_format_id dst_format)
4223 {
4229 }
4231 HRESULT CDECL wined3d_check_device_type(const struct wined3d *wined3d, UINT adapter_idx, WINED3DDEVTYPE device_type,
4232 enum wined3d_format_id display_format, enum wined3d_format_id backbuffer_format, BOOL windowed)
4233 {
4234 UINT mode_count;
4235 HRESULT hr;
4237 TRACE("wined3d %p, adapter_idx %u, device_type %s, display_format %s, backbuffer_format %s, windowed %#x.\n",
4244 /* The task of this function is to check whether a certain display / backbuffer format
4245 * combination is available on the given adapter. In fullscreen mode microsoft specified
4246 * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer
4247 * and display format should match exactly.
4248 * In windowed mode format conversion can occur and this depends on the driver. When format
4249 * conversion is done, this function should nevertheless fail and applications need to use
4250 * CheckDeviceFormatConversion.
4251 * At the moment we assume that fullscreen and windowed have the same capabilities. */
4253 /* There are only 4 display formats. */
4258 {
4259 TRACE_(d3d_caps)("Format %s is not supported as display format.\n", debug_d3dformat(display_format));
4261 }
4263 /* If the requested display format is not available, don't continue. */
4266 {
4267 TRACE_(d3d_caps)("No available modes for display format %s.\n", debug_d3dformat(display_format));
4269 }
4271 /* Windowed mode allows you to specify WINED3DFMT_UNKNOWN for the backbuffer format,
4272 * it means 'reuse' the display format for the backbuffer. */
4274 {
4277 }
4279 /* In FULLSCREEN mode WINED3DFMT_B5G6R5_UNORM can only be mixed with
4280 * backbuffer format WINED3DFMT_B5G6R5_UNORM. */
4282 {
4286 }
4288 /* In FULLSCREEN mode WINED3DFMT_B5G5R5X1_UNORM can only be mixed with
4289 * backbuffer formats WINED3DFMT_B5G5R5X1_UNORM and
4290 * WINED3DFMT_B5G5R5A1_UNORM. */
4292 && !(backbuffer_format == WINED3DFMT_B5G5R5X1_UNORM || backbuffer_format == WINED3DFMT_B5G5R5A1_UNORM))
4293 {
4297 }
4299 /* In FULLSCREEN mode WINED3DFMT_B8G8R8X8_UNORM can only be mixed with
4300 * backbuffer formats WINED3DFMT_B8G8R8X8_UNORM and
4301 * WINED3DFMT_B8G8R8A8_UNORM. */
4303 && !(backbuffer_format == WINED3DFMT_B8G8R8X8_UNORM || backbuffer_format == WINED3DFMT_B8G8R8A8_UNORM))
4304 {
4308 }
4310 /* WINED3DFMT_B10G10R10A2_UNORM is only allowed in fullscreen mode and it
4311 * can only be mixed with backbuffer format WINED3DFMT_B10G10R10A2_UNORM. */
4314 {
4318 }
4320 /* Use CheckDeviceFormat to see if the backbuffer_format is usable with the given display_format */
4328 }
4330 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
4331 subset of a D3DCAPS9 structure. However, it has to come via a void *
4332 as the d3d8 interface cannot import the d3d9 header */
4335 {
4352 /* ------------------------------------------------
4353 The following fields apply to both d3d8 and d3d9
4354 ------------------------------------------------ */
4355 /* Not quite true, but use h/w supported by opengl I suppose */
4356 caps->DeviceType = (device_type == WINED3DDEVTYPE_HAL) ? WINED3DDEVTYPE_HAL : WINED3DDEVTYPE_REF;
4361 WINED3DCAPS2_FULLSCREENGAMMA |
4362 WINED3DCAPS2_DYNAMICTEXTURES;
4367 WINED3DCAPS3_COPY_TO_VIDMEM |
4368 WINED3DCAPS3_COPY_TO_SYSTEMMEM;
4371 WINED3DPRESENT_INTERVAL_ONE;
4374 WINED3DCURSORCAPS_LOWRES;
4377 WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
4378 WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
4379 WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
4380 WINED3DDEVCAPS_DRAWPRIMTLVERTEX |
4381 WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
4382 WINED3DDEVCAPS_EXECUTEVIDEOMEMORY |
4383 WINED3DDEVCAPS_PUREDEVICE |
4384 WINED3DDEVCAPS_HWRASTERIZATION |
4385 WINED3DDEVCAPS_TEXTUREVIDEOMEMORY |
4386 WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
4387 WINED3DDEVCAPS_CANRENDERAFTERFLIP |
4388 WINED3DDEVCAPS_DRAWPRIMITIVES2 |
4389 WINED3DDEVCAPS_DRAWPRIMITIVES2EX |
4390 WINED3DDEVCAPS_RTPATCHES;
4393 WINED3DPMISCCAPS_CULLCCW |
4394 WINED3DPMISCCAPS_CULLCW |
4395 WINED3DPMISCCAPS_COLORWRITEENABLE |
4396 WINED3DPMISCCAPS_CLIPTLVERTS |
4397 WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
4398 WINED3DPMISCCAPS_MASKZ |
4399 WINED3DPMISCCAPS_BLENDOP |
4400 WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING;
4401 /* TODO:
4402 WINED3DPMISCCAPS_NULLREFERENCE
4403 WINED3DPMISCCAPS_FOGANDSPECULARALPHA
4404 WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
4405 WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
4407 if (gl_info->supported[EXT_BLEND_EQUATION_SEPARATE] && gl_info->supported[EXT_BLEND_FUNC_SEPARATE])
4413 WINED3DPRASTERCAPS_PAT |
4414 WINED3DPRASTERCAPS_WFOG |
4415 WINED3DPRASTERCAPS_ZFOG |
4416 WINED3DPRASTERCAPS_FOGVERTEX |
4417 WINED3DPRASTERCAPS_FOGTABLE |
4418 WINED3DPRASTERCAPS_STIPPLE |
4419 WINED3DPRASTERCAPS_SUBPIXEL |
4420 WINED3DPRASTERCAPS_ZTEST |
4421 WINED3DPRASTERCAPS_SCISSORTEST |
4422 WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
4423 WINED3DPRASTERCAPS_DEPTHBIAS;
4426 {
4428 WINED3DPRASTERCAPS_ZBIAS |
4429 WINED3DPRASTERCAPS_MIPMAPLODBIAS;
4430 }
4432 {
4434 }
4435 /* FIXME Add:
4436 WINED3DPRASTERCAPS_COLORPERSPECTIVE
4437 WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
4438 WINED3DPRASTERCAPS_ANTIALIASEDGES
4439 WINED3DPRASTERCAPS_ZBUFFERLESSHSR
4440 WINED3DPRASTERCAPS_WBUFFER */
4443 WINED3DPCMPCAPS_EQUAL |
4444 WINED3DPCMPCAPS_GREATER |
4445 WINED3DPCMPCAPS_GREATEREQUAL |
4446 WINED3DPCMPCAPS_LESS |
4447 WINED3DPCMPCAPS_LESSEQUAL |
4448 WINED3DPCMPCAPS_NEVER |
4449 WINED3DPCMPCAPS_NOTEQUAL;
4452 WINED3DPBLENDCAPS_BOTHSRCALPHA |
4453 WINED3DPBLENDCAPS_DESTALPHA |
4454 WINED3DPBLENDCAPS_DESTCOLOR |
4455 WINED3DPBLENDCAPS_INVDESTALPHA |
4456 WINED3DPBLENDCAPS_INVDESTCOLOR |
4457 WINED3DPBLENDCAPS_INVSRCALPHA |
4458 WINED3DPBLENDCAPS_INVSRCCOLOR |
4459 WINED3DPBLENDCAPS_ONE |
4460 WINED3DPBLENDCAPS_SRCALPHA |
4461 WINED3DPBLENDCAPS_SRCALPHASAT |
4462 WINED3DPBLENDCAPS_SRCCOLOR |
4463 WINED3DPBLENDCAPS_ZERO;
4466 WINED3DPBLENDCAPS_DESTCOLOR |
4467 WINED3DPBLENDCAPS_INVDESTALPHA |
4468 WINED3DPBLENDCAPS_INVDESTCOLOR |
4469 WINED3DPBLENDCAPS_INVSRCALPHA |
4470 WINED3DPBLENDCAPS_INVSRCCOLOR |
4471 WINED3DPBLENDCAPS_ONE |
4472 WINED3DPBLENDCAPS_SRCALPHA |
4473 WINED3DPBLENDCAPS_SRCCOLOR |
4474 WINED3DPBLENDCAPS_ZERO;
4475 /* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
4476 * according to the glBlendFunc manpage
4477 *
4478 * WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA are
4479 * legacy settings for srcblend only
4480 */
4483 {
4486 }
4490 WINED3DPCMPCAPS_EQUAL |
4491 WINED3DPCMPCAPS_GREATER |
4492 WINED3DPCMPCAPS_GREATEREQUAL |
4493 WINED3DPCMPCAPS_LESS |
4494 WINED3DPCMPCAPS_LESSEQUAL |
4495 WINED3DPCMPCAPS_NEVER |
4496 WINED3DPCMPCAPS_NOTEQUAL;
4499 WINED3DPSHADECAPS_COLORGOURAUDRGB |
4500 WINED3DPSHADECAPS_ALPHAFLATBLEND |
4501 WINED3DPSHADECAPS_ALPHAGOURAUDBLEND |
4502 WINED3DPSHADECAPS_COLORFLATRGB |
4503 WINED3DPSHADECAPS_FOGFLAT |
4504 WINED3DPSHADECAPS_FOGGOURAUD |
4505 WINED3DPSHADECAPS_SPECULARFLATRGB;
4508 WINED3DPTEXTURECAPS_ALPHAPALETTE |
4509 WINED3DPTEXTURECAPS_TRANSPARENCY |
4510 WINED3DPTEXTURECAPS_BORDER |
4511 WINED3DPTEXTURECAPS_MIPMAP |
4512 WINED3DPTEXTURECAPS_PROJECTED |
4513 WINED3DPTEXTURECAPS_PERSPECTIVE;
4516 {
4518 WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
4519 }
4522 {
4524 WINED3DPTEXTURECAPS_MIPVOLUMEMAP;
4526 {
4528 }
4529 }
4532 {
4534 WINED3DPTEXTURECAPS_MIPCUBEMAP;
4536 {
4538 }
4539 }
4542 WINED3DPTFILTERCAPS_MAGFPOINT |
4543 WINED3DPTFILTERCAPS_MINFLINEAR |
4544 WINED3DPTFILTERCAPS_MINFPOINT |
4545 WINED3DPTFILTERCAPS_MIPFLINEAR |
4546 WINED3DPTFILTERCAPS_MIPFPOINT |
4547 WINED3DPTFILTERCAPS_LINEAR |
4548 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4549 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4550 WINED3DPTFILTERCAPS_MIPLINEAR |
4551 WINED3DPTFILTERCAPS_MIPNEAREST |
4552 WINED3DPTFILTERCAPS_NEAREST;
4555 {
4557 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4558 }
4561 {
4563 WINED3DPTFILTERCAPS_MAGFPOINT |
4564 WINED3DPTFILTERCAPS_MINFLINEAR |
4565 WINED3DPTFILTERCAPS_MINFPOINT |
4566 WINED3DPTFILTERCAPS_MIPFLINEAR |
4567 WINED3DPTFILTERCAPS_MIPFPOINT |
4568 WINED3DPTFILTERCAPS_LINEAR |
4569 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4570 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4571 WINED3DPTFILTERCAPS_MIPLINEAR |
4572 WINED3DPTFILTERCAPS_MIPNEAREST |
4573 WINED3DPTFILTERCAPS_NEAREST;
4576 {
4578 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4579 }
4580 }
4581 else
4582 {
4584 }
4587 {
4589 WINED3DPTFILTERCAPS_MAGFPOINT |
4590 WINED3DPTFILTERCAPS_MINFLINEAR |
4591 WINED3DPTFILTERCAPS_MINFPOINT |
4592 WINED3DPTFILTERCAPS_MIPFLINEAR |
4593 WINED3DPTFILTERCAPS_MIPFPOINT |
4594 WINED3DPTFILTERCAPS_LINEAR |
4595 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4596 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4597 WINED3DPTFILTERCAPS_MIPLINEAR |
4598 WINED3DPTFILTERCAPS_MIPNEAREST |
4599 WINED3DPTFILTERCAPS_NEAREST;
4600 }
4601 else
4602 {
4604 }
4607 WINED3DPTADDRESSCAPS_CLAMP |
4608 WINED3DPTADDRESSCAPS_WRAP;
4611 {
4613 }
4615 {
4617 }
4619 {
4621 }
4624 {
4626 WINED3DPTADDRESSCAPS_CLAMP |
4627 WINED3DPTADDRESSCAPS_WRAP;
4629 {
4631 }
4633 {
4635 }
4637 {
4639 }
4640 }
4641 else
4642 {
4644 }
4647 WINED3DLINECAPS_ZTEST |
4648 WINED3DLINECAPS_BLEND |
4649 WINED3DLINECAPS_ALPHACMP |
4650 WINED3DLINECAPS_FOG;
4651 /* WINED3DLINECAPS_ANTIALIAS is not supported on Windows, and dx and gl seem to have a different
4652 * idea how generating the smoothing alpha values works; the result is different
4653 */
4660 else
4675 WINED3DSTENCILCAPS_INCRSAT |
4676 WINED3DSTENCILCAPS_INVERT |
4677 WINED3DSTENCILCAPS_KEEP |
4678 WINED3DSTENCILCAPS_REPLACE |
4679 WINED3DSTENCILCAPS_ZERO;
4681 {
4683 WINED3DSTENCILCAPS_INCR;
4684 }
4686 {
4688 }
4702 /* FIXME: Add D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
4704 WINED3DVTXPCAPS_MATERIALSOURCE7 |
4705 WINED3DVTXPCAPS_POSITIONALLIGHTS |
4706 WINED3DVTXPCAPS_LOCALVIEWER |
4707 WINED3DVTXPCAPS_VERTEXFOG |
4708 WINED3DVTXPCAPS_TEXGEN;
4710 caps->MaxPrimitiveCount = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
4715 /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
4717 WINED3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET;
4726 WINED3DPTFILTERCAPS_MAGFPOINT |
4727 WINED3DPTFILTERCAPS_MINFLINEAR |
4728 WINED3DPTFILTERCAPS_MAGFLINEAR;
4734 /* Add shader misc caps. Only some of them belong to the shader parts of the pipeline */
4737 /* This takes care for disabling vertex shader or pixel shader caps while leaving the other one enabled.
4738 * Ignore shader model capabilities if disabled in config
4739 */
4741 {
4745 }
4746 else
4747 {
4750 }
4753 {
4760 }
4766 /* The following caps are shader specific, but they are things we cannot detect, or which
4767 * are the same among all shader models. So to avoid code duplication set the shader version
4768 * specific, but otherwise constant caps here
4769 */
4771 {
4772 /* Where possible set the caps based on OpenGL extensions and if they
4773 * aren't set (in case of software rendering) use the VS 3.0 from
4774 * MSDN or else if there's OpenGL spec use a hardcoded value minimum
4775 * VS3.0 value. */
4777 /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4780 /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
4783 caps->MaxVShaderInstructionsExecuted = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
4784 caps->MaxVertexShader30InstructionSlots = max(512, adapter->gl_info.limits.arb_vs_instructions);
4785 }
4787 {
4795 }
4796 else
4805 }
4808 {
4809 /* Where possible set the caps based on OpenGL extensions and if they
4810 * aren't set (in case of software rendering) use the PS 3.0 from
4811 * MSDN or else if there's OpenGL spec use a hardcoded value minimum
4812 * PS 3.0 value. */
4814 /* Caps is more or less undocumented on MSDN but it appears to be
4815 * used for PS20Caps based on results from R9600/FX5900/Geforce6800
4816 * cards from Windows */
4818 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS |
4819 WINED3DPS20CAPS_PREDICATION |
4820 WINED3DPS20CAPS_NODEPENDENTREADLIMIT |
4821 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
4822 /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4825 /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
4827 /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
4833 }
4835 {
4836 /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
4840 caps->PS20Caps.StaticFlowControlDepth = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minimum: 1 */
4841 /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
4846 }
4848 {
4857 }
4860 {
4861 /* OpenGL supports all the formats below, perhaps not always
4862 * without conversion, but it supports them.
4863 * Further GLSL doesn't seem to have an official unsigned type so
4864 * don't advertise it yet as I'm not sure how we handle it.
4865 * We might need to add some clamping in the shader engine to
4866 * support it.
4867 * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
4869 WINED3DDTCAPS_UBYTE4N |
4870 WINED3DDTCAPS_SHORT2N |
4871 WINED3DDTCAPS_SHORT4N;
4873 {
4875 WINED3DDTCAPS_FLOAT16_4;
4876 }
4877 }
4878 else
4879 {
4881 }
4883 /* Set DirectDraw helper Caps */
4885 WINEDDCKEYCAPS_SRCBLT;
4887 WINEDDFXCAPS_BLTMIRRORLEFTRIGHT |
4888 WINEDDFXCAPS_BLTMIRRORUPDOWN |
4889 WINEDDFXCAPS_BLTROTATION90 |
4890 WINEDDFXCAPS_BLTSHRINKX |
4891 WINEDDFXCAPS_BLTSHRINKXN |
4892 WINEDDFXCAPS_BLTSHRINKY |
4893 WINEDDFXCAPS_BLTSHRINKXN |
4894 WINEDDFXCAPS_BLTSTRETCHX |
4895 WINEDDFXCAPS_BLTSTRETCHXN |
4896 WINEDDFXCAPS_BLTSTRETCHY |
4897 WINEDDFXCAPS_BLTSTRETCHYN;
4899 WINEDDCAPS_BLTCOLORFILL |
4900 WINEDDCAPS_BLTDEPTHFILL |
4901 WINEDDCAPS_BLTSTRETCH |
4902 WINEDDCAPS_CANBLTSYSMEM |
4903 WINEDDCAPS_CANCLIP |
4904 WINEDDCAPS_CANCLIPSTRETCHED |
4905 WINEDDCAPS_COLORKEY |
4906 WINEDDCAPS_COLORKEYHWASSIST |
4907 WINEDDCAPS_ALIGNBOUNDARYSRC;
4909 WINEDDPCAPS_PRIMARYSURFACE;
4911 /* Fill the ddraw caps structure */
4913 WINEDDCAPS_PALETTE |
4914 blit_caps;
4916 WINEDDCAPS2_NOPAGELOCKREQUIRED |
4917 WINEDDCAPS2_PRIMARYGAMMA |
4918 WINEDDCAPS2_WIDESURFACES |
4919 WINEDDCAPS2_CANRENDERWINDOWED;
4934 WINEDDSCAPS_BACKBUFFER |
4935 WINEDDSCAPS_FLIP |
4936 WINEDDSCAPS_FRONTBUFFER |
4937 WINEDDSCAPS_OFFSCREENPLAIN |
4938 WINEDDSCAPS_PALETTE |
4939 WINEDDSCAPS_PRIMARYSURFACE |
4940 WINEDDSCAPS_SYSTEMMEMORY |
4941 WINEDDSCAPS_VIDEOMEMORY |
4942 WINEDDSCAPS_VISIBLE;
4945 /* Set D3D caps if OpenGL is available. */
4947 {
4949 WINEDDSCAPS_MIPMAP |
4950 WINEDDSCAPS_TEXTURE |
4951 WINEDDSCAPS_ZBUFFER;
4953 }
4956 }
4958 HRESULT CDECL wined3d_device_create(struct wined3d *wined3d, UINT adapter_idx, WINED3DDEVTYPE device_type,
4959 HWND focus_window, DWORD flags, BYTE surface_alignment, struct wined3d_device_parent *device_parent,
4961 {
4963 HRESULT hr;
4965 TRACE("wined3d %p, adapter_idx %u, device_type %#x, focus_window %p, flags %#x, device_parent %p, device %p.\n",
4968 /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
4969 * number and create a device without a 3D adapter for 2D only operation. */
4975 {
4978 }
4983 {
4987 }
4995 }
4998 {
5002 }
5005 {
5008 }
5011 {
5014 }
5016 /* Helper functions for providing vertex data to opengl. The arrays are initialized based on
5017 * the extension detection and are used in drawStridedSlow
5018 */
5020 {
5028 }
5031 {
5035 {
5039 }
5040 else
5041 {
5043 }
5044 }
5047 {
5054 }
5057 {
5064 }
5067 {
5069 }
5072 {
5109 /* No 4 component entry points here */
5113 {
5115 }
5116 else
5117 {
5119 }
5122 {
5125 }
5126 else
5127 {
5129 }
5143 /* Only 3 component entry points here. Test how others behave. Float4 normals are used
5144 * by one of our tests, trying to pass it to the pixel shader, which fails on Windows.
5145 */
5149 normal_funcs[WINED3D_FFP_EMIT_FLOAT4] = (glAttribFunc)glNormal3fv; /* Just ignore the 4th value */
5164 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT1] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord1fvARB);
5165 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2fvARB);
5166 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord3fvARB);
5167 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4fvARB);
5170 multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2svARB);
5171 multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4svARB);
5180 {
5181 /* Not supported by ARB_HALF_FLOAT_VERTEX, so check for NV_HALF_FLOAT */
5182 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2hvNV);
5183 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4hvNV);
5187 }
5188 }
5190 /* Do not call while under the GL lock. */
5192 {
5194 BOOL ret;
5197 /* No need to hold any lock. The calling library makes sure only one thread calls
5198 * wined3d simultaneously
5199 */
5204 #ifdef USE_WIN32_OPENGL
5205 #define USE_GL_FUNC(pfn) pfn = (void*)GetProcAddress(mod_gl, #pfn);
5210 }
5211 #else
5212 #define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
5213 /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
5215 #endif
5216 }
5218 /* Load WGL core functions from opengl32.dll */
5219 #define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
5220 WGL_FUNCS_GEN;
5221 #undef USE_WGL_FUNC
5226 }
5228 /* Dynamically load all GL core functions */
5229 GL_FUNCS_GEN;
5230 #undef USE_GL_FUNC
5232 /* Load glFinish and glFlush from opengl32.dll even if we're not using WIN32 opengl
5233 * otherwise because we have to use winex11.drv's override
5234 */
5235 #ifdef USE_WIN32_OPENGL
5238 #else
5241 #endif
5246 /* For now only one default adapter */
5247 {
5255 DISPLAY_DEVICEW DisplayDevice;
5256 HDC hdc;
5264 {
5268 }
5273 {
5276 }
5283 }
5289 }
5297 /* Initialize the Adapter's DeviceName which is required for ChangeDisplaySettings and friends */
5304 {
5313 adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, adapter->nCfgs * sizeof(*adapter->cfgs));
5328 {
5329 res = GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, nAttribs, attribs, values));
5334 /* Cache the pixel format */
5349 /* Check multisample support */
5351 {
5355 /* value[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether multisampling is supported.
5356 * value[1] = number of multi sample buffers*/
5359 }
5360 }
5367 cfgs++;
5368 }
5369 }
5370 else
5371 {
5374 adapter->nCfgs = 0; /* We won't accept all formats e.g. software accelerated ones will be skipped */
5378 {
5379 PIXELFORMATDESCRIPTOR ppfd;
5385 /* We only want HW acceleration using an OpenGL ICD driver.
5386 * PFD_GENERIC_FORMAT = slow opengl 1.1 gdi software rendering
5387 * PFD_GENERIC_ACCELERATED = partial hw acceleration using a MCD driver (e.g. 3dfx minigl)
5388 */
5390 {
5393 }
5404 cfgs->iPixelType = (ppfd.iPixelType == PFD_TYPE_RGBA) ? WGL_TYPE_RGBA_ARB : WGL_TYPE_COLORINDEX_ARB;
5414 cfgs++;
5416 }
5418 /* Yikes we haven't found any suitable formats. This should only happen in case of GDI software rendering which we can't use anyway as its 3D functionality is very, very limited */
5420 {
5426 }
5427 }
5429 /* D16, D24X8 and D24S8 are common depth / depth+stencil formats. All drivers support them though this doesn't
5430 * mean that the format is offered in hardware. For instance Geforce8 cards don't have offer D16 in hardware
5431 * but just fake it using D24(X8?) which is fine. D3D also allows that.
5432 * Some display drivers (i915 on Linux) only report mixed depth+stencil formats like D24S8. MSDN clearly mentions
5433 * that only on lockable formats (e.g. D16_locked) the bit order is guaranteed and that on other formats the
5434 * driver is allowed to consume more bits EXCEPT for stencil bits.
5435 *
5436 * Mark an adapter with this broken stencil behavior.
5437 */
5440 {
5441 /* Nearly all drivers offer depth formats without stencil, only on i915 this if-statement won't be entered. */
5445 }
5446 }
5453 }
5459 nogl_adapter:
5460 /* Initialize an adapter for ddraw-only memory counting */
5471 else
5478 }
5483 {
5484 wined3d_null_wined3d_object_destroyed,
5485 };
5487 /* Do not call while under the GL lock. */
5489 {
5496 {
5499 {
5502 }
5503 }
5506 }