| blob | a93895eea718f273482243c832df3575971625fe |
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 inconvenient
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 },
1178 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6300, "AMD Radeon HD 6300 series Graphics", DRIVER_AMD_R600, 1024},
1183 /* Intel cards */
1184 {HW_VENDOR_INTEL, CARD_INTEL_I830G, "Intel(R) 82830M Graphics Controller", DRIVER_INTEL_GMA800, 32 },
1185 {HW_VENDOR_INTEL, CARD_INTEL_I855G, "Intel(R) 82852/82855 GM/GME Graphics Controller", DRIVER_INTEL_GMA800, 32 },
1186 {HW_VENDOR_INTEL, CARD_INTEL_I865G, "Intel(R) 82865G Graphics Controller", DRIVER_INTEL_GMA800, 32 },
1187 {HW_VENDOR_INTEL, CARD_INTEL_I915G, "Intel(R) 82915G/GV/910GL Express Chipset Family", DRIVER_INTEL_GMA900, 64 },
1188 {HW_VENDOR_INTEL, CARD_INTEL_I915GM, "Mobile Intel(R) 915GM/GMS,910GML Express Chipset Family", DRIVER_INTEL_GMA900, 64 },
1189 {HW_VENDOR_INTEL, CARD_INTEL_I945GM, "Mobile Intel(R) 945GM Express Chipset Family", DRIVER_INTEL_GMA950, 64 },
1190 {HW_VENDOR_INTEL, CARD_INTEL_X3100, "Mobile Intel(R) 965 Express Chipset Family", DRIVER_INTEL_GMA3000, 128},
1191 {HW_VENDOR_INTEL, CARD_INTEL_GM45, "Mobile Intel(R) GM45 Express Chipset Family", DRIVER_INTEL_GMA3000, 512}
1192 };
1194 static const struct driver_version_information *get_driver_version_info(enum wined3d_display_driver driver,
1196 {
1201 {
1205 {
1210 }
1211 }
1213 }
1217 {
1218 OSVERSIONINFOW os_version;
1219 WORD driver_os_version;
1226 {
1229 }
1233 {
1236 }
1239 /* Set a default amount of video memory (64MB). In general this code isn't used unless the user
1240 * overrides the pci ids to a card which is not in our database. */
1246 {
1250 }
1251 else
1252 {
1255 {
1257 /* If needed we could distinguish between 9x and NT4, but this code won't make
1258 * sense for NT4 since it had no way to obtain this info through DirectDraw 3.0.
1259 */
1271 {
1274 }
1275 else
1276 {
1278 {
1281 }
1284 }
1293 }
1294 }
1296 /* When we reach this stage we always have a vendor or device id (it can be a default one).
1297 * This means that unless the ids are overriden, we will always find a GPU description. */
1299 {
1301 {
1308 }
1309 }
1312 {
1313 TRACE_(d3d_caps)("Overriding amount of video memory with: %d byte\n", wined3d_settings.emulated_textureram);
1315 }
1317 /* Try to obtain driver version information for the current Windows version. This fails in
1318 * some cases:
1319 * - the gpu is not available on the currently selected OS version:
1320 * - Geforce GTX480 on Win98. When running applications in compatibility mode on Windows,
1321 * version information for the current Windows version is returned instead of faked info.
1322 * We do the same and assume the default Windows version to emulate is WinXP.
1323 *
1324 * - Videocard is a Riva TNT but winver is set to win7 (there are no drivers for this beast)
1325 * For now return the XP driver info. Perhaps later on we should return VESA.
1326 *
1327 * - the gpu is not in our database (can happen when the user overrides the vendor_id / device_id)
1328 * This could be an indication that our database is not up to date, so this should be fixed.
1329 */
1332 {
1336 }
1337 else
1338 {
1341 {
1345 }
1346 else
1347 {
1353 FIXME("Unable to find a driver/device info for vendor_id=%#x device_id=%#x for driver_model=%d\n",
1355 }
1356 }
1360 }
1362 /* Context activation is done by the caller. */
1364 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
1365 {
1369 {
1373 }
1375 /* Find out if PBOs work as they are supposed to. */
1377 }
1380 {
1388 if (*ptr++ != '.') ERR_(d3d_caps)("Invalid opengl version string: %s.\n", debugstr_a(gl_version));
1395 }
1397 static enum wined3d_gl_vendor wined3d_guess_gl_vendor(struct wined3d_gl_info *gl_info, const char *gl_vendor_string, const char *gl_renderer)
1398 {
1400 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
1401 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
1402 * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
1403 *
1404 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
1405 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
1406 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
1407 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
1408 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
1409 * the chance that other implementations support them is rather small since Win32 QuickTime uses
1410 * DirectDraw, not OpenGL. */
1424 /* Intel switched from Intel(R) to Intel® recently, so just match Intel. */
1443 }
1445 static enum wined3d_pci_vendor wined3d_guess_card_vendor(const char *gl_vendor_string, const char *gl_renderer)
1446 {
1463 /* Intel switched from Intel(R) to Intel® recently, so just match Intel. */
1473 FIXME_(d3d_caps)("Received unrecognized GL_VENDOR %s. Returning HW_VENDOR_NVIDIA.\n", debugstr_a(gl_vendor_string));
1476 }
1479 {
1498 }
1500 static enum wined3d_pci_device select_card_nvidia_binary(const struct wined3d_gl_info *gl_info,
1502 {
1507 {
1508 static const struct
1509 {
1512 }
1513 cards[] =
1514 {
1566 };
1569 {
1572 }
1574 /* Geforce8-compatible fall back if the GPU is not in the list yet */
1576 }
1578 /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
1579 * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
1580 */
1582 {
1583 static const struct
1584 {
1587 }
1588 cards[] =
1589 {
1603 };
1606 {
1609 }
1611 /* Geforce 6/7 - lowend */
1613 }
1616 {
1617 /* GeforceFX - highend */
1622 {
1624 }
1626 /* GeforceFX - midend */
1631 {
1633 }
1635 /* GeforceFX - lowend */
1637 }
1640 {
1642 {
1644 }
1647 }
1650 {
1652 {
1654 }
1657 {
1659 }
1662 {
1664 }
1667 }
1670 {
1672 }
1675 }
1679 {
1682 /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1683 *
1684 * Beware: renderer string do not match exact card model,
1685 * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1687 {
1690 static const struct
1691 {
1694 }
1695 cards[] =
1696 {
1697 /* Evergreen */
1708 /* R700 */
1721 /* R600/R700 integrated */
1725 /* R600 */
1739 };
1742 {
1745 }
1747 /* Default for when no GPU has been found */
1749 }
1752 {
1753 /* Radeon R5xx */
1759 {
1761 }
1763 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300/X2500/HD2300 (lowend R5xx)
1764 * Note X2300/X2500/HD2300 are R5xx GPUs with a 2xxx naming but they are still DX9-only */
1775 )
1776 {
1778 }
1780 /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1782 {
1784 }
1786 /* Radeon R3xx */
1788 }
1797 }
1801 {
1804 {
1805 /* MacOS calls the card GMA X3100, otherwise known as GM965/GL960 */
1807 }
1810 {
1811 /* MacOS calls the card GMA 950, but everywhere else the PCI ID is named 945GM */
1813 }
1822 }
1826 {
1827 UINT d3d_level;
1830 /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1831 *
1832 * Beware: renderer string do not match exact card model,
1833 * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1835 {
1836 /* 20101109 - These are never returned by current Gallium radeon
1837 * drivers: R700, RV790, R680, RV535, RV516, R410, RS485, RV360, RV351.
1838 *
1839 * These are returned but not handled: RC410, RV380. */
1840 static const struct
1841 {
1844 }
1845 cards[] =
1846 {
1847 /* Northern Islands */
1853 /* Evergreen */
1859 /* R700 */
1866 /* R600/R700 integrated */
1869 /* R600 */
1877 /* R500 */
1886 /* R400 */
1894 /* Radeon Xpress - onboard, DX9b, Shader 2.0, 300-400MHz */
1902 /* R300 */
1910 };
1913 {
1916 }
1917 }
1921 {
1922 static const struct
1923 {
1926 }
1927 cards[] =
1928 {
1929 /* R700 */
1936 /* R600/R700 integrated */
1939 /* R600 */
1947 };
1950 {
1953 }
1954 }
1963 }
1967 {
1968 UINT d3d_level;
1971 {
1974 static const struct
1975 {
1978 }
1979 cards[] =
1980 {
2035 };
2038 {
2041 }
2042 }
2056 }
2059 struct vendor_card_selection
2060 {
2064 enum wined3d_pci_device (*select_card)(const struct wined3d_gl_info *gl_info, const char *gl_renderer);
2065 };
2068 {
2070 {GL_VENDOR_APPLE, HW_VENDOR_NVIDIA, "Apple OSX NVidia binary driver", select_card_nvidia_binary},
2078 };
2081 static enum wined3d_pci_device wined3d_guess_card(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
2083 {
2084 UINT d3d_level;
2086 /* Above is a list of Nvidia and ATI GPUs. Both vendors have dozens of
2087 * different GPUs with roughly the same features. In most cases GPUs from a
2088 * certain family differ in clockspeeds, the amount of video memory and the
2089 * number of shader pipelines.
2090 *
2091 * A Direct3D device object contains the PCI id (vendor + device) of the
2092 * videocard which is used for rendering. Various applications use this
2093 * information to get a rough estimation of the features of the card and
2094 * some might use it for enabling 3d effects only on certain types of
2095 * videocards. In some cases games might even use it to work around bugs
2096 * which happen on certain videocards/driver combinations. The problem is
2097 * that OpenGL only exposes a rendering string containing the name of the
2098 * videocard and not the PCI id.
2099 *
2100 * Various games depend on the PCI id, so somehow we need to provide one.
2101 * A simple option is to parse the renderer string and translate this to
2102 * the right PCI id. This is a lot of work because there are more than 200
2103 * GPUs just for Nvidia. Various cards share the same renderer string, so
2104 * the amount of code might be 'small' but there are quite a number of
2105 * exceptions which would make this a pain to maintain. Another way would
2106 * be to query the PCI id from the operating system (assuming this is the
2107 * videocard which is used for rendering which is not always the case).
2108 * This would work but it is not very portable. Second it would not work
2109 * well in, let's say, a remote X situation in which the amount of 3d
2110 * features which can be used is limited.
2111 *
2112 * As said most games only use the PCI id to get an indication of the
2113 * capabilities of the card. It doesn't really matter if the given id is
2114 * the correct one if we return the id of a card with similar 3d features.
2115 *
2116 * The code below checks the OpenGL capabilities of a videocard and matches
2117 * that to a certain level of Direct3D functionality. Once a card passes
2118 * the Direct3D9 check, we know that the card (in case of Nvidia) is at
2119 * least a GeforceFX. To give a better estimate we do a basic check on the
2120 * renderer string but if that won't pass we return a default card. This
2121 * way is better than maintaining a full card database as even without a
2122 * full database we can return a card with similar features. Second the
2123 * size of the database can be made quite small because when you know what
2124 * type of 3d functionality a card has, you know to which GPU family the
2125 * GPU must belong. Because of this you only have to check a small part of
2126 * the renderer string to distinguishes between different models from that
2127 * family.
2128 *
2129 * The code also selects a default amount of video memory which we will
2130 * use for an estimation of the amount of free texture memory. In case of
2131 * real D3D the amount of texture memory includes video memory and system
2132 * memory (to be specific AGP memory or in case of PCIE TurboCache /
2133 * HyperMemory). We don't know how much system memory can be addressed by
2134 * the system but we can make a reasonable estimation about the amount of
2135 * video memory. If the value is slightly wrong it doesn't matter as we
2136 * didn't include AGP-like memory which makes the amount of addressable
2137 * memory higher and second OpenGL isn't that critical it moves to system
2138 * memory behind our backs if really needed. Note that the amount of video
2139 * memory can be overruled using a registry setting. */
2144 {
2150 }
2155 /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
2156 * for Nvidia was because the hardware and drivers they make are of good quality. This makes
2157 * them a good generic choice. */
2169 }
2171 static const struct fragment_pipeline *select_fragment_implementation(struct wined3d_adapter *adapter)
2172 {
2184 }
2186 static const struct wined3d_shader_backend_ops *select_shader_backend(struct wined3d_adapter *adapter)
2187 {
2191 if (vs_selected_mode == SHADER_GLSL || ps_selected_mode == SHADER_GLSL) return &glsl_shader_backend;
2192 if (vs_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_ARB) return &arb_program_shader_backend;
2194 }
2197 {
2205 }
2208 {
2209 DWORD ver;
2211 #define USE_GL_FUNC(type, pfn, ext, replace) \
2212 if (gl_info->supported[ext]) gl_info->pfn = (type)pwglGetProcAddress(#pfn); \
2213 else if ((ver = ver_for_ext(ext)) && ver <= gl_version) gl_info->pfn = (type)pwglGetProcAddress(#replace); \
2214 else gl_info->pfn = NULL;
2216 GL_EXT_FUNCS_GEN;
2217 #undef USE_GL_FUNC
2219 #define USE_GL_FUNC(type, pfn, ext, replace) gl_info->pfn = (type)pwglGetProcAddress(#pfn);
2220 WGL_EXT_FUNCS_GEN;
2221 #undef USE_GL_FUNC
2222 }
2224 /* Context activation is done by the caller. */
2226 {
2236 GLint gl_max;
2239 HDC hdc;
2240 DWORD gl_version;
2250 {
2254 }
2259 {
2263 }
2265 /* Parse the GL_VERSION field into major and minor information */
2269 {
2273 }
2276 /*
2277 * Initialize openGL extension related variables
2278 * with Default values
2279 */
2286 gl_info->limits.combined_samplers = gl_info->limits.fragment_samplers + gl_info->limits.vertex_samplers;
2299 /* Retrieve opengl defaults */
2317 /* Parse the gl supported features, in theory enabling parts of our code appropriately. */
2320 {
2324 }
2333 {
2346 {
2349 {
2353 }
2354 }
2355 }
2357 /* Now work out what GL support this card really has */
2362 /* Now mark all the extensions supported which are included in the opengl core version. Do this *after*
2363 * loading the functions, otherwise the code above will load the extension entry points instead of the
2364 * core functions, which may not work. */
2366 {
2369 {
2372 }
2373 }
2378 {
2379 /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
2380 * The apple extension interacts with some other apple exts. Disable the NV
2381 * extension if the apple one is support to prevent confusion in other parts
2382 * of the code. */
2384 }
2386 {
2387 /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
2388 *
2389 * The enums are the same:
2390 * GL_RGBA16F_ARB = GL_RGBA_FLOAT16_APPLE = 0x881A
2391 * GL_RGB16F_ARB = GL_RGB_FLOAT16_APPLE = 0x881B
2392 * GL_RGBA32F_ARB = GL_RGBA_FLOAT32_APPLE = 0x8814
2393 * GL_RGB32F_ARB = GL_RGB_FLOAT32_APPLE = 0x8815
2394 * GL_HALF_FLOAT_ARB = GL_HALF_APPLE = 0x140B
2395 */
2397 {
2400 }
2402 {
2405 }
2406 }
2408 {
2409 /* GL_ARB_map_buffer_range and GL_APPLE_flush_buffer_range provide the same
2410 * functionality. Prefer the ARB extension */
2412 }
2414 {
2417 }
2419 {
2422 }
2424 {
2427 }
2428 if (!gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] && gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC])
2429 {
2430 TRACE_(d3d_caps)(" IMPLIED: ARB_texture_compression_rgtc support (by EXT_texture_compression_rgtc).\n");
2432 }
2434 {
2436 {
2437 /* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2
2438 * are supported. The nv extensions provide the same functionality as the
2439 * ATI one, and a bit more(signed pixelformats). */
2441 }
2442 }
2445 {
2449 }
2451 {
2455 }
2457 {
2463 {
2464 GLint tmp;
2467 }
2468 else
2469 {
2471 }
2475 {
2476 GLint tmp;
2482 /* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup
2483 * is known at shader link time. In a vertex shader + pixel shader combination this isn't
2484 * an issue because then the sampler setup only depends on the two shaders. If a pixel
2485 * shader is used with fixed function vertex processing we're fine too because fixed function
2486 * vertex processing doesn't use any samplers. If fixed function fragment processing is
2487 * used we have to make sure that all vertex sampler setups are valid together with all
2488 * possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES
2489 * <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards).
2490 * dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and
2491 * dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have
2492 * a fixed function pipeline anymore.
2493 *
2494 * So this is just a check to check that our assumption holds true. If not, write a warning
2495 * and reduce the number of vertex samplers or probably disable vertex texture fetch. */
2498 {
2504 else
2506 }
2507 }
2508 else
2509 {
2511 }
2514 }
2516 {
2520 }
2522 {
2526 }
2528 {
2532 }
2534 {
2535 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2537 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM float constants: %d.\n", gl_info->limits.arb_ps_float_constants);
2538 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
2542 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
2544 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_ps_temps);
2545 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
2547 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native instructions: %d.\n", gl_info->limits.arb_ps_instructions);
2548 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, &gl_max));
2550 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM local parameters: %d.\n", gl_info->limits.arb_ps_instructions);
2551 }
2553 {
2554 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2556 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM float constants: %d.\n", gl_info->limits.arb_vs_float_constants);
2557 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
2561 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
2563 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_vs_temps);
2564 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
2566 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native instructions: %d.\n", gl_info->limits.arb_vs_instructions);
2569 }
2571 {
2574 TRACE_(d3d_caps)("Max ARB_VERTEX_SHADER float constants: %u.\n", gl_info->limits.glsl_vs_float_constants);
2575 }
2577 {
2580 TRACE_(d3d_caps)("Max ARB_FRAGMENT_SHADER float constants: %u.\n", gl_info->limits.glsl_ps_float_constants);
2584 }
2586 {
2592 /* The format of the GLSL version string is "major.minor[.release] [vendor info]". */
2595 }
2597 {
2599 }
2600 else
2601 {
2603 }
2605 {
2606 /* If we have full NP2 texture support, disable
2607 * GL_ARB_texture_rectangle because we will never use it.
2608 * This saves a few redundant glDisable calls. */
2610 }
2612 {
2613 /* Disable NV_register_combiners and fragment shader if this is supported.
2614 * generally the NV extensions are preferred over the ATI ones, and this
2615 * extension is disabled if register_combiners and texture_shader2 are both
2616 * supported. So we reach this place only if we have incomplete NV dxlevel 8
2617 * fragment processing support. */
2622 }
2624 {
2625 /* GL_ARB_half_float_vertex is a subset of GL_NV_half_float. */
2627 }
2629 {
2631 }
2632 else
2633 {
2635 }
2648 /* In some cases the number of texture stages can be larger than the number
2649 * of samplers. The GF4 for example can use only 2 samplers (no fragment
2650 * shaders), but 8 texture stages (register combiners). */
2651 gl_info->limits.sampler_stages = max(gl_info->limits.fragment_samplers, gl_info->limits.texture_stages);
2654 {
2671 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv = gl_info->glGetFramebufferAttachmentParameteriv;
2674 }
2675 else
2676 {
2678 {
2694 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv = gl_info->glGetFramebufferAttachmentParameterivEXT;
2696 }
2698 {
2699 WARN_(d3d_caps)("Framebuffer objects not supported, falling back to backbuffer offscreen rendering mode.\n");
2701 }
2703 {
2705 }
2707 {
2708 gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->glRenderbufferStorageMultisampleEXT;
2709 }
2710 }
2712 /* MRTs are currently only supported when FBOs are used. */
2714 {
2716 }
2720 TRACE_(d3d_caps)("found GL_VENDOR (%s)->(0x%04x/0x%04x)\n", debugstr_a(gl_vendor_str), gl_vendor, card_vendor);
2723 TRACE_(d3d_caps)("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", card_vendor, device);
2734 /* Make sure there's an active HDC else the WGL extensions will fail */
2737 /* Not all GL drivers might offer WGL extensions e.g. VirtualBox */
2742 {
2744 }
2745 else
2746 {
2749 {
2768 }
2772 }
2776 }
2777 }
2778 }
2779 }
2786 }
2789 {
2794 }
2797 {
2801 }
2804 {
2810 return MonitorFromPoint(wined3d->adapters[adapter_idx].monitorPoint, MONITOR_DEFAULTTOPRIMARY);
2811 }
2813 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
2814 of the same bpp but different resolutions */
2816 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2819 {
2820 TRACE_(d3d_caps)("wined3d %p, adapter_idx %u, format %s.\n", wined3d, adapter_idx, debug_d3dformat(format_id));
2825 /* TODO: Store modes per adapter and read it from the adapter structure */
2827 {
2828 const struct wined3d_format *format = wined3d_get_format(&wined3d->adapters[adapter_idx].gl_info, format_id);
2832 DEVMODEW mode;
2838 {
2842 {
2843 /* This is for D3D8, do not enumerate P8 here */
2845 }
2847 {
2849 }
2850 }
2852 TRACE_(d3d_caps)("Returning %u matching modes (out of %u total) for adapter %u.\n", i, j, adapter_idx);
2855 }
2856 else
2857 {
2859 }
2862 }
2864 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2867 {
2871 /* Validate the parameters as much as possible */
2874 {
2876 }
2878 /* TODO: Store modes per adapter and read it from the adapter structure */
2880 {
2881 const struct wined3d_format *format = wined3d_get_format(&wined3d->adapters[adapter_idx].gl_info, format_id);
2883 DEVMODEW DevModeW;
2891 /* If we are filtering to a specific format (D3D9), then need to skip
2892 all unrelated modes, but if mode is irrelevant (D3D8), then we can
2893 just count through the ones with valid bit depths */
2895 {
2897 {
2898 /* This is for D3D8, do not enumerate P8 here */
2900 }
2902 {
2904 }
2905 }
2908 {
2909 TRACE_(d3d_caps)("No modes found for format (%x - %s)\n", format_id, debug_d3dformat(format_id));
2911 }
2914 /* Now get the display mode via the calculated index */
2916 {
2925 else
2927 }
2928 else
2929 {
2932 }
2937 }
2938 else
2939 {
2941 }
2944 }
2946 HRESULT CDECL wined3d_get_adapter_display_mode(const struct wined3d *wined3d, UINT adapter_idx,
2948 {
2955 {
2956 DEVMODEW DevModeW;
2970 }
2971 else
2972 {
2974 }
2979 }
2981 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
2982 and fields being inserted in the middle, a new structure is used in place */
2985 {
2997 /* Return the information requested */
3001 {
3006 }
3009 {
3014 }
3016 /* Note that d3d8 doesn't supply a device name. */
3018 {
3023 {
3026 }
3030 }
3038 memcpy(&identifier->device_identifier, &IID_D3DDEVICE_D3DUID, sizeof(identifier->device_identifier));
3044 }
3048 {
3051 /* Float formats need FBOs. If FBOs are used this function isn't called */
3056 {
3059 }
3074 }
3076 /* Probably a RGBA_float or color index mode */
3078 }
3082 {
3087 {
3090 }
3092 /* Float formats need FBOs. If FBOs are used this function isn't called */
3098 /* On some modern cards like the Geforce8/9 GLX doesn't offer some dephthstencil formats which D3D9 reports.
3099 * We can safely report 'compatible' formats (e.g. D24 can be used for D16) as long as we aren't dealing with
3100 * a lockable format. This also helps D3D <= 7 as they expect D16 which isn't offered without this on Geforce8 cards. */
3104 /* Some cards like Intel i915 ones only offer D24S8 but lots of games also need a format without stencil, so
3105 * allow more stencil bits than requested. */
3110 }
3114 enum wined3d_format_id render_target_format_id, enum wined3d_format_id depth_stencil_format_id)
3115 {
3132 {
3135 {
3138 }
3139 }
3140 else
3141 {
3149 {
3152 {
3155 }
3156 }
3157 }
3164 }
3166 HRESULT CDECL wined3d_check_device_multisample_type(const struct wined3d *wined3d, UINT adapter_idx,
3169 {
3181 /* TODO: Handle windowed, add more quality levels. */
3184 {
3187 }
3189 /* By default multisampling is disabled right now as it causes issues
3190 * on some Nvidia driver versions and it doesn't work well in combination
3191 * with FBOs yet. */
3200 {
3207 {
3220 }
3221 }
3223 {
3229 {
3233 }
3238 {
3247 /* Not all drivers report alpha-less formats since they use 32-bit
3248 * anyway, so accept alpha even if we didn't ask for it. */
3260 }
3261 }
3263 }
3265 /* Check if we support bumpmapping for a format */
3266 static BOOL CheckBumpMapCapability(const struct wined3d_adapter *adapter, const struct wined3d_format *format)
3267 {
3268 /* Ask the fixed function pipeline implementation if it can deal
3269 * with the conversion. If we've got a GL extension giving native
3270 * support this will be an identity conversion. */
3273 }
3275 /* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */
3278 {
3281 /* Only allow depth/stencil formats */
3285 {
3286 /* With FBOs WGL limitations do not apply, but the format needs to be FBO attachable */
3288 }
3289 else
3290 {
3291 /* Walk through all WGL pixel formats to find a match */
3293 {
3298 }
3299 }
3302 }
3304 static BOOL CheckFilterCapability(const struct wined3d_adapter *adapter, const struct wined3d_format *format)
3305 {
3306 /* The flags entry of a format contains the filtering capability */
3310 }
3312 /* Check the render target capabilities of a format */
3315 {
3316 /* Filter out non-RT formats */
3319 {
3325 getColorBits(adapter_format, &AdapterRed, &AdapterGreen, &AdapterBlue, &AdapterAlpha, &AdapterTotalSize);
3328 /* In backbuffer mode the front and backbuffer share the same WGL pixelformat.
3329 * The format must match in RGB, alpha is allowed to be different. (Only the backbuffer can have alpha) */
3330 if(!((AdapterRed == CheckRed) && (AdapterGreen == CheckGreen) && (AdapterBlue == CheckBlue))) {
3333 }
3335 /* Check if there is a WGL pixel format matching the requirements, the format should also be window
3336 * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
3338 {
3341 {
3345 }
3346 }
3347 }
3349 {
3350 /* For now return TRUE for FBOs until we have some proper checks.
3351 * Note that this function will only be called when the format is around for texturing. */
3353 }
3355 }
3357 static BOOL CheckSrgbReadCapability(const struct wined3d_adapter *adapter, const struct wined3d_format *format)
3358 {
3360 }
3362 static BOOL CheckSrgbWriteCapability(const struct wined3d_adapter *adapter, const struct wined3d_format *format)
3363 {
3364 /* Only offer SRGB writing on X8R8G8B8/A8R8G8B8 when we use ARB or GLSL shaders as we are
3365 * doing the color fixup in shaders.
3366 * Note Windows drivers (at least on the Geforce 8800) also offer this on R5G6B5. */
3368 {
3376 }
3377 }
3379 TRACE_(d3d_caps)("[FAILED] - sRGB writes not supported by format %s.\n", debug_d3dformat(format->id));
3381 }
3383 /* Check if a format support blending in combination with pixel shaders */
3386 {
3387 /* The flags entry of a format contains the post pixel shader blending capability */
3391 }
3393 static BOOL CheckWrapAndMipCapability(const struct wined3d_adapter *adapter, const struct wined3d_format *format)
3394 {
3395 /* OpenGL supports mipmapping on all formats basically. Wrapping is unsupported,
3396 * but we have to report mipmapping so we cannot reject this flag. Tests show that
3397 * windows reports WRAPANDMIP on unfilterable surfaces as well, apparently to show
3398 * that wrapping is supported. The lack of filtering will sort out the mipmapping
3399 * capability anyway.
3400 *
3401 * For now lets report this on all formats, but in the future we may want to
3402 * restrict it to some should games need that
3403 */
3405 }
3407 /* Check if a texture format is supported on the given adapter */
3408 static BOOL CheckTextureCapability(const struct wined3d_adapter *adapter, const struct wined3d_format *format)
3409 {
3413 {
3414 /*****
3415 * supported: RGB(A) formats
3416 */
3438 /*****
3439 * Not supported: Palettized
3440 * Only some Geforce/Voodoo3/G400 cards offer 8-bit textures in case of <=Direct3D7.
3441 * Since it is not widely available, don't offer it. Further no Windows driver offers
3442 * WINED3DFMT_P8_UINT_A8_NORM, so don't offer it either.
3443 */
3448 /*****
3449 * Supported: (Alpha)-Luminance
3450 */
3457 /* Not supported on Windows, thus disabled */
3462 /*****
3463 * Supported: Depth/Stencil formats
3464 */
3482 /*****
3483 * Not supported everywhere(depends on GL_ATI_envmap_bumpmap or
3484 * GL_NV_texture_shader). Emulated by shaders
3485 */
3491 /* Ask the shader backend if it can deal with the conversion. If
3492 * we've got a GL extension giving native support this will be an
3493 * identity conversion. */
3495 {
3498 }
3508 {
3511 }
3516 /*****
3517 * Odd formats - not supported
3518 */
3530 /*****
3531 * WINED3DFMT_R8G8_SNORM_Cx: Not supported right now
3532 */
3537 /* YUV formats */
3541 {
3544 }
3553 {
3556 }
3560 /* Not supported */
3565 /* Floating point formats */
3570 {
3573 }
3581 {
3584 }
3588 /* ATI instancing hack: Although ATI cards do not support Shader Model 3.0, they support
3589 * instancing. To query if the card supports instancing CheckDeviceFormat with the special format
3590 * MAKEFOURCC('I','N','S','T') is used. Should a (broken) app check for this provide a proper return value.
3591 * We can do instancing with all shader versions, but we need vertex shaders.
3592 *
3593 * Additionally applications have to set the D3DRS_POINTSIZE render state to MAKEFOURCC('I','N','S','T') once
3594 * to enable instancing. WineD3D doesn't need that and just ignores it.
3595 *
3596 * With Shader Model 3.0 capable cards Instancing 'just works' in Windows.
3597 */
3601 {
3604 }
3608 /* Some weird FOURCC formats */
3615 /* Vendor specific formats */
3619 {
3622 {
3625 }
3629 }
3633 /* Depth bound test. To query if the card supports it CheckDeviceFormat with the special
3634 * format MAKEFOURCC('N','V','D','B') is used.
3635 * It is enabled by setting D3DRS_ADAPTIVETESS_X render state to MAKEFOURCC('N','V','D','B') and
3636 * then controlled by setting D3DRS_ADAPTIVETESS_Z (zMin) and D3DRS_ADAPTIVETESS_W (zMax)
3637 * to test value.
3638 */
3641 {
3644 }
3650 /* These formats seem to be similar to the HILO formats in GL_NV_texture_shader. NVHU
3651 * is said to be GL_UNSIGNED_HILO16, NVHS GL_SIGNED_HILO16. Rumours say that d3d computes
3652 * a 3rd channel similarly to D3DFMT_CxV8U8(So NVHS could be called D3DFMT_CxV16U16).
3653 * ATI refused to support formats which can easily be emulated with pixel shaders, so
3654 * Applications have to deal with not having NVHS and NVHU.
3655 */
3670 }
3672 }
3677 WINED3DSURFTYPE SurfaceType)
3678 {
3680 {
3682 {
3706 }
3707 }
3709 /* All format that are supported for textures are supported for surfaces as well */
3711 /* All depth stencil formats are supported on surfaces */
3714 /* If opengl can't process the format natively, the blitter may be able to convert it */
3718 {
3721 }
3723 /* Reject other formats */
3726 }
3730 {
3732 }
3736 WINED3DRESOURCETYPE resource_type, enum wined3d_format_id check_format_id, WINED3DSURFTYPE surface_type)
3737 {
3744 TRACE_(d3d_caps)("wined3d %p, adapter_idx %u, device_type %s, adapter_format %s, usage %s, %s,\n"
3754 {
3756 /* Cubetexture allows:
3757 * - WINED3DUSAGE_AUTOGENMIPMAP
3758 * - WINED3DUSAGE_DEPTHSTENCIL
3759 * - WINED3DUSAGE_DYNAMIC
3760 * - WINED3DUSAGE_NONSECURE (d3d9ex)
3761 * - WINED3DUSAGE_RENDERTARGET
3762 * - WINED3DUSAGE_SOFTWAREPROCESSING
3763 * - WINED3DUSAGE_QUERY_WRAPANDMIP
3764 */
3766 {
3769 }
3772 {
3775 }
3778 {
3781 }
3784 {
3786 /* When autogenmipmap isn't around continue and return
3787 * WINED3DOK_NOAUTOGEN instead of D3D_OK. */
3789 else
3791 }
3793 /* Always report dynamic locking. */
3798 {
3800 {
3803 }
3805 }
3807 /* Always report software processing. */
3812 {
3814 {
3817 }
3819 }
3822 {
3824 {
3827 }
3829 }
3832 {
3834 {
3837 }
3839 }
3842 {
3844 {
3847 }
3849 }
3852 {
3854 {
3857 }
3859 }
3862 {
3864 {
3867 }
3869 }
3873 /* Surface allows:
3874 * - WINED3DUSAGE_DEPTHSTENCIL
3875 * - WINED3DUSAGE_NONSECURE (d3d9ex)
3876 * - WINED3DUSAGE_RENDERTARGET
3877 */
3879 {
3882 }
3885 {
3887 {
3890 }
3892 }
3895 {
3897 {
3900 }
3902 }
3905 {
3907 {
3910 }
3912 }
3916 /* Texture allows:
3917 * - WINED3DUSAGE_AUTOGENMIPMAP
3918 * - WINED3DUSAGE_DEPTHSTENCIL
3919 * - WINED3DUSAGE_DMAP
3920 * - WINED3DUSAGE_DYNAMIC
3921 * - WINED3DUSAGE_NONSECURE (d3d9ex)
3922 * - WINED3DUSAGE_RENDERTARGET
3923 * - WINED3DUSAGE_SOFTWAREPROCESSING
3924 * - WINED3DUSAGE_TEXTAPI (d3d9ex)
3925 * - WINED3DUSAGE_QUERY_WRAPANDMIP
3926 */
3928 {
3931 }
3934 {
3937 }
3940 {
3942 /* When autogenmipmap isn't around continue and return
3943 * WINED3DOK_NOAUTOGEN instead of D3D_OK. */
3945 else
3947 }
3949 /* Always report dynamic locking. */
3954 {
3956 {
3959 }
3961 }
3963 /* Always report software processing. */
3968 {
3970 {
3973 }
3975 }
3978 {
3980 {
3983 }
3985 }
3988 {
3990 {
3993 }
3995 }
3998 {
4000 {
4003 }
4005 }
4008 {
4010 {
4013 }
4015 }
4018 {
4020 {
4023 }
4025 }
4028 {
4030 {
4033 }
4035 }
4038 {
4040 {
4043 }
4045 {
4048 }
4050 }
4055 /* Volume is to VolumeTexture what Surface is to Texture, but its
4056 * usage caps are not documented. Most driver seem to offer
4057 * (nearly) the same on Volume and VolumeTexture, so do that too.
4058 *
4059 * Volumetexture allows:
4060 * - D3DUSAGE_DYNAMIC
4061 * - D3DUSAGE_NONSECURE (d3d9ex)
4062 * - D3DUSAGE_SOFTWAREPROCESSING
4063 * - D3DUSAGE_QUERY_WRAPANDMIP
4064 */
4066 {
4069 }
4072 {
4075 }
4078 {
4081 }
4083 /* Filter formats that need conversion; For one part, this
4084 * conversion is unimplemented, and volume textures are huge, so
4085 * it would be a big performance hit. Unless we hit an application
4086 * needing one of those formats, don't advertize them to avoid
4087 * leading applications into temptation. The windows drivers don't
4088 * support most of those formats on volumes anyway, except for
4089 * WINED3DFMT_R32_FLOAT. */
4091 {
4105 {
4108 }
4113 {
4116 }
4124 /* The GL_EXT_texture_compression_s3tc spec requires that
4125 * loading an s3tc compressed texture results in an error.
4126 * While the D3D refrast does support s3tc volumes, at
4127 * least the nvidia windows driver does not, so we're free
4128 * not to support this format. */
4133 /* Do nothing, continue with checking the format below */
4135 }
4137 /* Always report dynamic locking. */
4141 /* Always report software processing. */
4146 {
4148 {
4151 }
4153 }
4156 {
4158 {
4161 }
4163 }
4166 {
4168 {
4171 }
4173 }
4176 {
4178 {
4181 }
4183 }
4186 {
4188 {
4191 }
4193 }
4196 {
4198 {
4201 }
4203 }
4209 }
4211 /* When the usage_caps exactly matches usage return WINED3D_OK except for
4212 * the situation in which WINED3DUSAGE_AUTOGENMIPMAP isn't around, then
4213 * WINED3DOK_NOAUTOGEN is returned if all the other usage flags match. */
4219 TRACE_(d3d_caps)("[FAILED] - Usage %#x requested for format %s and resource_type %s but only %#x is available.\n",
4223 }
4225 HRESULT CDECL wined3d_check_device_format_conversion(const struct wined3d *wined3d, UINT adapter_idx,
4226 WINED3DDEVTYPE device_type, enum wined3d_format_id src_format, enum wined3d_format_id dst_format)
4227 {
4233 }
4235 HRESULT CDECL wined3d_check_device_type(const struct wined3d *wined3d, UINT adapter_idx, WINED3DDEVTYPE device_type,
4236 enum wined3d_format_id display_format, enum wined3d_format_id backbuffer_format, BOOL windowed)
4237 {
4238 UINT mode_count;
4239 HRESULT hr;
4241 TRACE("wined3d %p, adapter_idx %u, device_type %s, display_format %s, backbuffer_format %s, windowed %#x.\n",
4248 /* The task of this function is to check whether a certain display / backbuffer format
4249 * combination is available on the given adapter. In fullscreen mode microsoft specified
4250 * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer
4251 * and display format should match exactly.
4252 * In windowed mode format conversion can occur and this depends on the driver. When format
4253 * conversion is done, this function should nevertheless fail and applications need to use
4254 * CheckDeviceFormatConversion.
4255 * At the moment we assume that fullscreen and windowed have the same capabilities. */
4257 /* There are only 4 display formats. */
4262 {
4263 TRACE_(d3d_caps)("Format %s is not supported as display format.\n", debug_d3dformat(display_format));
4265 }
4267 /* If the requested display format is not available, don't continue. */
4270 {
4271 TRACE_(d3d_caps)("No available modes for display format %s.\n", debug_d3dformat(display_format));
4273 }
4275 /* Windowed mode allows you to specify WINED3DFMT_UNKNOWN for the backbuffer format,
4276 * it means 'reuse' the display format for the backbuffer. */
4278 {
4281 }
4283 /* In FULLSCREEN mode WINED3DFMT_B5G6R5_UNORM can only be mixed with
4284 * backbuffer format WINED3DFMT_B5G6R5_UNORM. */
4286 {
4290 }
4292 /* In FULLSCREEN mode WINED3DFMT_B5G5R5X1_UNORM can only be mixed with
4293 * backbuffer formats WINED3DFMT_B5G5R5X1_UNORM and
4294 * WINED3DFMT_B5G5R5A1_UNORM. */
4296 && !(backbuffer_format == WINED3DFMT_B5G5R5X1_UNORM || backbuffer_format == WINED3DFMT_B5G5R5A1_UNORM))
4297 {
4301 }
4303 /* In FULLSCREEN mode WINED3DFMT_B8G8R8X8_UNORM can only be mixed with
4304 * backbuffer formats WINED3DFMT_B8G8R8X8_UNORM and
4305 * WINED3DFMT_B8G8R8A8_UNORM. */
4307 && !(backbuffer_format == WINED3DFMT_B8G8R8X8_UNORM || backbuffer_format == WINED3DFMT_B8G8R8A8_UNORM))
4308 {
4312 }
4314 /* WINED3DFMT_B10G10R10A2_UNORM is only allowed in fullscreen mode and it
4315 * can only be mixed with backbuffer format WINED3DFMT_B10G10R10A2_UNORM. */
4318 {
4322 }
4324 /* Use CheckDeviceFormat to see if the backbuffer_format is usable with the given display_format */
4332 }
4334 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
4335 subset of a D3DCAPS9 structure. However, it has to come via a void *
4336 as the d3d8 interface cannot import the d3d9 header */
4339 {
4356 /* ------------------------------------------------
4357 The following fields apply to both d3d8 and d3d9
4358 ------------------------------------------------ */
4359 /* Not quite true, but use h/w supported by opengl I suppose */
4360 caps->DeviceType = (device_type == WINED3DDEVTYPE_HAL) ? WINED3DDEVTYPE_HAL : WINED3DDEVTYPE_REF;
4365 WINED3DCAPS2_FULLSCREENGAMMA |
4366 WINED3DCAPS2_DYNAMICTEXTURES;
4371 WINED3DCAPS3_COPY_TO_VIDMEM |
4372 WINED3DCAPS3_COPY_TO_SYSTEMMEM;
4375 WINED3DPRESENT_INTERVAL_ONE;
4378 WINED3DCURSORCAPS_LOWRES;
4381 WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
4382 WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
4383 WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
4384 WINED3DDEVCAPS_DRAWPRIMTLVERTEX |
4385 WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
4386 WINED3DDEVCAPS_EXECUTEVIDEOMEMORY |
4387 WINED3DDEVCAPS_PUREDEVICE |
4388 WINED3DDEVCAPS_HWRASTERIZATION |
4389 WINED3DDEVCAPS_TEXTUREVIDEOMEMORY |
4390 WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
4391 WINED3DDEVCAPS_CANRENDERAFTERFLIP |
4392 WINED3DDEVCAPS_DRAWPRIMITIVES2 |
4393 WINED3DDEVCAPS_DRAWPRIMITIVES2EX |
4394 WINED3DDEVCAPS_RTPATCHES;
4397 WINED3DPMISCCAPS_CULLCCW |
4398 WINED3DPMISCCAPS_CULLCW |
4399 WINED3DPMISCCAPS_COLORWRITEENABLE |
4400 WINED3DPMISCCAPS_CLIPTLVERTS |
4401 WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
4402 WINED3DPMISCCAPS_MASKZ |
4403 WINED3DPMISCCAPS_BLENDOP |
4404 WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING;
4405 /* TODO:
4406 WINED3DPMISCCAPS_NULLREFERENCE
4407 WINED3DPMISCCAPS_FOGANDSPECULARALPHA
4408 WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
4409 WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
4411 if (gl_info->supported[EXT_BLEND_EQUATION_SEPARATE] && gl_info->supported[EXT_BLEND_FUNC_SEPARATE])
4417 WINED3DPRASTERCAPS_PAT |
4418 WINED3DPRASTERCAPS_WFOG |
4419 WINED3DPRASTERCAPS_ZFOG |
4420 WINED3DPRASTERCAPS_FOGVERTEX |
4421 WINED3DPRASTERCAPS_FOGTABLE |
4422 WINED3DPRASTERCAPS_STIPPLE |
4423 WINED3DPRASTERCAPS_SUBPIXEL |
4424 WINED3DPRASTERCAPS_ZTEST |
4425 WINED3DPRASTERCAPS_SCISSORTEST |
4426 WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
4427 WINED3DPRASTERCAPS_DEPTHBIAS;
4430 {
4432 WINED3DPRASTERCAPS_ZBIAS |
4433 WINED3DPRASTERCAPS_MIPMAPLODBIAS;
4434 }
4436 {
4438 }
4439 /* FIXME Add:
4440 WINED3DPRASTERCAPS_COLORPERSPECTIVE
4441 WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
4442 WINED3DPRASTERCAPS_ANTIALIASEDGES
4443 WINED3DPRASTERCAPS_ZBUFFERLESSHSR
4444 WINED3DPRASTERCAPS_WBUFFER */
4447 WINED3DPCMPCAPS_EQUAL |
4448 WINED3DPCMPCAPS_GREATER |
4449 WINED3DPCMPCAPS_GREATEREQUAL |
4450 WINED3DPCMPCAPS_LESS |
4451 WINED3DPCMPCAPS_LESSEQUAL |
4452 WINED3DPCMPCAPS_NEVER |
4453 WINED3DPCMPCAPS_NOTEQUAL;
4456 WINED3DPBLENDCAPS_BOTHSRCALPHA |
4457 WINED3DPBLENDCAPS_DESTALPHA |
4458 WINED3DPBLENDCAPS_DESTCOLOR |
4459 WINED3DPBLENDCAPS_INVDESTALPHA |
4460 WINED3DPBLENDCAPS_INVDESTCOLOR |
4461 WINED3DPBLENDCAPS_INVSRCALPHA |
4462 WINED3DPBLENDCAPS_INVSRCCOLOR |
4463 WINED3DPBLENDCAPS_ONE |
4464 WINED3DPBLENDCAPS_SRCALPHA |
4465 WINED3DPBLENDCAPS_SRCALPHASAT |
4466 WINED3DPBLENDCAPS_SRCCOLOR |
4467 WINED3DPBLENDCAPS_ZERO;
4470 WINED3DPBLENDCAPS_DESTCOLOR |
4471 WINED3DPBLENDCAPS_INVDESTALPHA |
4472 WINED3DPBLENDCAPS_INVDESTCOLOR |
4473 WINED3DPBLENDCAPS_INVSRCALPHA |
4474 WINED3DPBLENDCAPS_INVSRCCOLOR |
4475 WINED3DPBLENDCAPS_ONE |
4476 WINED3DPBLENDCAPS_SRCALPHA |
4477 WINED3DPBLENDCAPS_SRCCOLOR |
4478 WINED3DPBLENDCAPS_ZERO;
4479 /* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
4480 * according to the glBlendFunc manpage
4481 *
4482 * WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA are
4483 * legacy settings for srcblend only
4484 */
4487 {
4490 }
4494 WINED3DPCMPCAPS_EQUAL |
4495 WINED3DPCMPCAPS_GREATER |
4496 WINED3DPCMPCAPS_GREATEREQUAL |
4497 WINED3DPCMPCAPS_LESS |
4498 WINED3DPCMPCAPS_LESSEQUAL |
4499 WINED3DPCMPCAPS_NEVER |
4500 WINED3DPCMPCAPS_NOTEQUAL;
4503 WINED3DPSHADECAPS_COLORGOURAUDRGB |
4504 WINED3DPSHADECAPS_ALPHAFLATBLEND |
4505 WINED3DPSHADECAPS_ALPHAGOURAUDBLEND |
4506 WINED3DPSHADECAPS_COLORFLATRGB |
4507 WINED3DPSHADECAPS_FOGFLAT |
4508 WINED3DPSHADECAPS_FOGGOURAUD |
4509 WINED3DPSHADECAPS_SPECULARFLATRGB;
4512 WINED3DPTEXTURECAPS_ALPHAPALETTE |
4513 WINED3DPTEXTURECAPS_TRANSPARENCY |
4514 WINED3DPTEXTURECAPS_BORDER |
4515 WINED3DPTEXTURECAPS_MIPMAP |
4516 WINED3DPTEXTURECAPS_PROJECTED |
4517 WINED3DPTEXTURECAPS_PERSPECTIVE;
4520 {
4522 WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
4523 }
4526 {
4528 WINED3DPTEXTURECAPS_MIPVOLUMEMAP;
4530 {
4532 }
4533 }
4536 {
4538 WINED3DPTEXTURECAPS_MIPCUBEMAP;
4540 {
4542 }
4543 }
4546 WINED3DPTFILTERCAPS_MAGFPOINT |
4547 WINED3DPTFILTERCAPS_MINFLINEAR |
4548 WINED3DPTFILTERCAPS_MINFPOINT |
4549 WINED3DPTFILTERCAPS_MIPFLINEAR |
4550 WINED3DPTFILTERCAPS_MIPFPOINT |
4551 WINED3DPTFILTERCAPS_LINEAR |
4552 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4553 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4554 WINED3DPTFILTERCAPS_MIPLINEAR |
4555 WINED3DPTFILTERCAPS_MIPNEAREST |
4556 WINED3DPTFILTERCAPS_NEAREST;
4559 {
4561 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4562 }
4565 {
4567 WINED3DPTFILTERCAPS_MAGFPOINT |
4568 WINED3DPTFILTERCAPS_MINFLINEAR |
4569 WINED3DPTFILTERCAPS_MINFPOINT |
4570 WINED3DPTFILTERCAPS_MIPFLINEAR |
4571 WINED3DPTFILTERCAPS_MIPFPOINT |
4572 WINED3DPTFILTERCAPS_LINEAR |
4573 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4574 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4575 WINED3DPTFILTERCAPS_MIPLINEAR |
4576 WINED3DPTFILTERCAPS_MIPNEAREST |
4577 WINED3DPTFILTERCAPS_NEAREST;
4580 {
4582 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4583 }
4584 }
4585 else
4586 {
4588 }
4591 {
4593 WINED3DPTFILTERCAPS_MAGFPOINT |
4594 WINED3DPTFILTERCAPS_MINFLINEAR |
4595 WINED3DPTFILTERCAPS_MINFPOINT |
4596 WINED3DPTFILTERCAPS_MIPFLINEAR |
4597 WINED3DPTFILTERCAPS_MIPFPOINT |
4598 WINED3DPTFILTERCAPS_LINEAR |
4599 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4600 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4601 WINED3DPTFILTERCAPS_MIPLINEAR |
4602 WINED3DPTFILTERCAPS_MIPNEAREST |
4603 WINED3DPTFILTERCAPS_NEAREST;
4604 }
4605 else
4606 {
4608 }
4611 WINED3DPTADDRESSCAPS_CLAMP |
4612 WINED3DPTADDRESSCAPS_WRAP;
4615 {
4617 }
4619 {
4621 }
4623 {
4625 }
4628 {
4630 WINED3DPTADDRESSCAPS_CLAMP |
4631 WINED3DPTADDRESSCAPS_WRAP;
4633 {
4635 }
4637 {
4639 }
4641 {
4643 }
4644 }
4645 else
4646 {
4648 }
4651 WINED3DLINECAPS_ZTEST |
4652 WINED3DLINECAPS_BLEND |
4653 WINED3DLINECAPS_ALPHACMP |
4654 WINED3DLINECAPS_FOG;
4655 /* WINED3DLINECAPS_ANTIALIAS is not supported on Windows, and dx and gl seem to have a different
4656 * idea how generating the smoothing alpha values works; the result is different
4657 */
4664 else
4679 WINED3DSTENCILCAPS_INCRSAT |
4680 WINED3DSTENCILCAPS_INVERT |
4681 WINED3DSTENCILCAPS_KEEP |
4682 WINED3DSTENCILCAPS_REPLACE |
4683 WINED3DSTENCILCAPS_ZERO;
4685 {
4687 WINED3DSTENCILCAPS_INCR;
4688 }
4690 {
4692 }
4706 /* FIXME: Add D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
4708 WINED3DVTXPCAPS_MATERIALSOURCE7 |
4709 WINED3DVTXPCAPS_POSITIONALLIGHTS |
4710 WINED3DVTXPCAPS_LOCALVIEWER |
4711 WINED3DVTXPCAPS_VERTEXFOG |
4712 WINED3DVTXPCAPS_TEXGEN;
4714 caps->MaxPrimitiveCount = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
4719 /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
4721 WINED3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET;
4730 WINED3DPTFILTERCAPS_MAGFPOINT |
4731 WINED3DPTFILTERCAPS_MINFLINEAR |
4732 WINED3DPTFILTERCAPS_MAGFLINEAR;
4738 /* Add shader misc caps. Only some of them belong to the shader parts of the pipeline */
4741 /* This takes care for disabling vertex shader or pixel shader caps while leaving the other one enabled.
4742 * Ignore shader model capabilities if disabled in config
4743 */
4745 {
4749 }
4750 else
4751 {
4754 }
4757 {
4764 }
4770 /* The following caps are shader specific, but they are things we cannot detect, or which
4771 * are the same among all shader models. So to avoid code duplication set the shader version
4772 * specific, but otherwise constant caps here
4773 */
4775 {
4776 /* Where possible set the caps based on OpenGL extensions and if they
4777 * aren't set (in case of software rendering) use the VS 3.0 from
4778 * MSDN or else if there's OpenGL spec use a hardcoded value minimum
4779 * VS3.0 value. */
4781 /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4784 /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
4787 caps->MaxVShaderInstructionsExecuted = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
4788 caps->MaxVertexShader30InstructionSlots = max(512, adapter->gl_info.limits.arb_vs_instructions);
4789 }
4791 {
4799 }
4800 else
4809 }
4812 {
4813 /* Where possible set the caps based on OpenGL extensions and if they
4814 * aren't set (in case of software rendering) use the PS 3.0 from
4815 * MSDN or else if there's OpenGL spec use a hardcoded value minimum
4816 * PS 3.0 value. */
4818 /* Caps is more or less undocumented on MSDN but it appears to be
4819 * used for PS20Caps based on results from R9600/FX5900/Geforce6800
4820 * cards from Windows */
4822 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS |
4823 WINED3DPS20CAPS_PREDICATION |
4824 WINED3DPS20CAPS_NODEPENDENTREADLIMIT |
4825 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
4826 /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4829 /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
4831 /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
4837 }
4839 {
4840 /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
4844 caps->PS20Caps.StaticFlowControlDepth = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minimum: 1 */
4845 /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
4850 }
4852 {
4861 }
4864 {
4865 /* OpenGL supports all the formats below, perhaps not always
4866 * without conversion, but it supports them.
4867 * Further GLSL doesn't seem to have an official unsigned type so
4868 * don't advertise it yet as I'm not sure how we handle it.
4869 * We might need to add some clamping in the shader engine to
4870 * support it.
4871 * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
4873 WINED3DDTCAPS_UBYTE4N |
4874 WINED3DDTCAPS_SHORT2N |
4875 WINED3DDTCAPS_SHORT4N;
4877 {
4879 WINED3DDTCAPS_FLOAT16_4;
4880 }
4881 }
4882 else
4883 {
4885 }
4887 /* Set DirectDraw helper Caps */
4889 WINEDDCKEYCAPS_SRCBLT;
4891 WINEDDFXCAPS_BLTMIRRORLEFTRIGHT |
4892 WINEDDFXCAPS_BLTMIRRORUPDOWN |
4893 WINEDDFXCAPS_BLTROTATION90 |
4894 WINEDDFXCAPS_BLTSHRINKX |
4895 WINEDDFXCAPS_BLTSHRINKXN |
4896 WINEDDFXCAPS_BLTSHRINKY |
4897 WINEDDFXCAPS_BLTSHRINKXN |
4898 WINEDDFXCAPS_BLTSTRETCHX |
4899 WINEDDFXCAPS_BLTSTRETCHXN |
4900 WINEDDFXCAPS_BLTSTRETCHY |
4901 WINEDDFXCAPS_BLTSTRETCHYN;
4903 WINEDDCAPS_BLTCOLORFILL |
4904 WINEDDCAPS_BLTDEPTHFILL |
4905 WINEDDCAPS_BLTSTRETCH |
4906 WINEDDCAPS_CANBLTSYSMEM |
4907 WINEDDCAPS_CANCLIP |
4908 WINEDDCAPS_CANCLIPSTRETCHED |
4909 WINEDDCAPS_COLORKEY |
4910 WINEDDCAPS_COLORKEYHWASSIST |
4911 WINEDDCAPS_ALIGNBOUNDARYSRC;
4913 WINEDDPCAPS_PRIMARYSURFACE;
4915 /* Fill the ddraw caps structure */
4917 WINEDDCAPS_PALETTE |
4918 blit_caps;
4920 WINEDDCAPS2_NOPAGELOCKREQUIRED |
4921 WINEDDCAPS2_PRIMARYGAMMA |
4922 WINEDDCAPS2_WIDESURFACES |
4923 WINEDDCAPS2_CANRENDERWINDOWED;
4938 WINEDDSCAPS_BACKBUFFER |
4939 WINEDDSCAPS_FLIP |
4940 WINEDDSCAPS_FRONTBUFFER |
4941 WINEDDSCAPS_OFFSCREENPLAIN |
4942 WINEDDSCAPS_PALETTE |
4943 WINEDDSCAPS_PRIMARYSURFACE |
4944 WINEDDSCAPS_SYSTEMMEMORY |
4945 WINEDDSCAPS_VIDEOMEMORY |
4946 WINEDDSCAPS_VISIBLE;
4949 /* Set D3D caps if OpenGL is available. */
4951 {
4953 WINEDDSCAPS_MIPMAP |
4954 WINEDDSCAPS_TEXTURE |
4955 WINEDDSCAPS_ZBUFFER;
4957 }
4960 }
4962 HRESULT CDECL wined3d_device_create(struct wined3d *wined3d, UINT adapter_idx, WINED3DDEVTYPE device_type,
4963 HWND focus_window, DWORD flags, BYTE surface_alignment, struct wined3d_device_parent *device_parent,
4965 {
4967 HRESULT hr;
4969 TRACE("wined3d %p, adapter_idx %u, device_type %#x, focus_window %p, flags %#x, device_parent %p, device %p.\n",
4972 /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
4973 * number and create a device without a 3D adapter for 2D only operation. */
4979 {
4982 }
4987 {
4991 }
4999 }
5002 {
5006 }
5009 {
5012 }
5015 {
5018 }
5020 /* Helper functions for providing vertex data to opengl. The arrays are initialized based on
5021 * the extension detection and are used in drawStridedSlow
5022 */
5024 {
5032 }
5035 {
5039 {
5043 }
5044 else
5045 {
5047 }
5048 }
5051 {
5058 }
5061 {
5068 }
5071 {
5073 }
5076 {
5113 /* No 4 component entry points here */
5117 {
5119 }
5120 else
5121 {
5123 }
5126 {
5129 }
5130 else
5131 {
5133 }
5147 /* Only 3 component entry points here. Test how others behave. Float4 normals are used
5148 * by one of our tests, trying to pass it to the pixel shader, which fails on Windows.
5149 */
5153 normal_funcs[WINED3D_FFP_EMIT_FLOAT4] = (glAttribFunc)glNormal3fv; /* Just ignore the 4th value */
5168 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT1] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord1fvARB);
5169 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2fvARB);
5170 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord3fvARB);
5171 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4fvARB);
5174 multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2svARB);
5175 multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4svARB);
5184 {
5185 /* Not supported by ARB_HALF_FLOAT_VERTEX, so check for NV_HALF_FLOAT */
5186 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2hvNV);
5187 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4hvNV);
5191 }
5192 }
5194 /* Do not call while under the GL lock. */
5196 {
5198 BOOL ret;
5201 /* No need to hold any lock. The calling library makes sure only one thread calls
5202 * wined3d simultaneously
5203 */
5208 #ifdef USE_WIN32_OPENGL
5209 #define USE_GL_FUNC(pfn) pfn = (void*)GetProcAddress(mod_gl, #pfn);
5214 }
5215 #else
5216 #define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
5217 /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
5219 #endif
5220 }
5222 /* Load WGL core functions from opengl32.dll */
5223 #define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
5224 WGL_FUNCS_GEN;
5225 #undef USE_WGL_FUNC
5230 }
5232 /* Dynamically load all GL core functions */
5233 GL_FUNCS_GEN;
5234 #undef USE_GL_FUNC
5236 /* Load glFinish and glFlush from opengl32.dll even if we're not using WIN32 opengl
5237 * otherwise because we have to use winex11.drv's override
5238 */
5239 #ifdef USE_WIN32_OPENGL
5242 #else
5245 #endif
5250 /* For now only one default adapter */
5251 {
5259 DISPLAY_DEVICEW DisplayDevice;
5260 HDC hdc;
5268 {
5272 }
5277 {
5280 }
5287 }
5293 }
5301 /* Initialize the Adapter's DeviceName which is required for ChangeDisplaySettings and friends */
5308 {
5317 adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, adapter->nCfgs * sizeof(*adapter->cfgs));
5332 {
5333 res = GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, nAttribs, attribs, values));
5338 /* Cache the pixel format */
5353 /* Check multisample support */
5355 {
5359 /* value[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether multisampling is supported.
5360 * value[1] = number of multi sample buffers*/
5363 }
5364 }
5371 cfgs++;
5372 }
5373 }
5374 else
5375 {
5378 adapter->nCfgs = 0; /* We won't accept all formats e.g. software accelerated ones will be skipped */
5382 {
5383 PIXELFORMATDESCRIPTOR ppfd;
5389 /* We only want HW acceleration using an OpenGL ICD driver.
5390 * PFD_GENERIC_FORMAT = slow opengl 1.1 gdi software rendering
5391 * PFD_GENERIC_ACCELERATED = partial hw acceleration using a MCD driver (e.g. 3dfx minigl)
5392 */
5394 {
5397 }
5408 cfgs->iPixelType = (ppfd.iPixelType == PFD_TYPE_RGBA) ? WGL_TYPE_RGBA_ARB : WGL_TYPE_COLORINDEX_ARB;
5418 cfgs++;
5420 }
5422 /* 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 */
5424 {
5430 }
5431 }
5433 /* D16, D24X8 and D24S8 are common depth / depth+stencil formats. All drivers support them though this doesn't
5434 * mean that the format is offered in hardware. For instance Geforce8 cards don't have offer D16 in hardware
5435 * but just fake it using D24(X8?) which is fine. D3D also allows that.
5436 * Some display drivers (i915 on Linux) only report mixed depth+stencil formats like D24S8. MSDN clearly mentions
5437 * that only on lockable formats (e.g. D16_locked) the bit order is guaranteed and that on other formats the
5438 * driver is allowed to consume more bits EXCEPT for stencil bits.
5439 *
5440 * Mark an adapter with this broken stencil behavior.
5441 */
5444 {
5445 /* Nearly all drivers offer depth formats without stencil, only on i915 this if-statement won't be entered. */
5449 }
5450 }
5457 }
5463 nogl_adapter:
5464 /* Initialize an adapter for ddraw-only memory counting */
5475 else
5482 }
5487 {
5488 wined3d_null_wined3d_object_destroyed,
5489 };
5491 /* Do not call while under the GL lock. */
5493 {
5500 {
5503 {
5506 }
5507 }
5510 }