directx.c File Reference

#include "config.h"
#include "wine/port.h"
#include <stdio.h>
#include "wined3d_private.h"
#include "wine/winternl.h"

Include dependency graph for directx.c:

Go to the source code of this file.

Classes
struct	wined3d_extension_map
struct	driver_quirk
struct	driver_version_information
struct	gpu_description
struct	wined3d_renderer_table
struct	gl_vendor_selection

Macros
#define	DEFAULT_REFRESH_RATE   0
#define	USE_GL_FUNC(pfn)   gl_info->gl_ops.ext.p_##pfn = (void *)wglGetProcAddress(#pfn);
#define	MAP_GL_FUNCTION(core_func, ext_func)
#define	MAP_GL_FUNCTION_CAST(core_func, ext_func)

Enumerations
enum	wined3d_display_driver {   DRIVER_AMD_RAGE_128PRO, DRIVER_AMD_R100, DRIVER_AMD_R300, DRIVER_AMD_R600,   DRIVER_AMD_RX, DRIVER_INTEL_GMA800, DRIVER_INTEL_GMA900, DRIVER_INTEL_GMA950,   DRIVER_INTEL_GMA3000, DRIVER_INTEL_HD4000, DRIVER_NVIDIA_TNT, DRIVER_NVIDIA_GEFORCE2MX,   DRIVER_NVIDIA_GEFORCEFX, DRIVER_NVIDIA_GEFORCE6, DRIVER_NVIDIA_GEFORCE8, DRIVER_VMWARE,   DRIVER_UNKNOWN }
enum	wined3d_driver_model {   DRIVER_MODEL_GENERIC, DRIVER_MODEL_WIN9X, DRIVER_MODEL_NT40, DRIVER_MODEL_NT5X,   DRIVER_MODEL_NT6X }
enum	wined3d_gl_vendor {   GL_VENDOR_UNKNOWN, GL_VENDOR_APPLE, GL_VENDOR_FGLRX, GL_VENDOR_MESA,   GL_VENDOR_NVIDIA }
enum	wined3d_d3d_level {   WINED3D_D3D_LEVEL_5, WINED3D_D3D_LEVEL_6, WINED3D_D3D_LEVEL_7, WINED3D_D3D_LEVEL_8,   WINED3D_D3D_LEVEL_9_SM2, WINED3D_D3D_LEVEL_9_SM3, WINED3D_D3D_LEVEL_10, WINED3D_D3D_LEVEL_11,   WINED3D_D3D_LEVEL_COUNT }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (d3d)
	WINE_DECLARE_DEBUG_CHANNEL (d3d_perf)
	WINE_DECLARE_DEBUG_CHANNEL (winediag)
static void	wined3d_caps_gl_ctx_destroy (const struct wined3d_caps_gl_ctx *ctx)
static BOOL	wined3d_caps_gl_ctx_create_attribs (struct wined3d_caps_gl_ctx *caps_gl_ctx, struct wined3d_gl_info *gl_info)
static BOOL	wined3d_caps_gl_ctx_create (struct wined3d_adapter *adapter, struct wined3d_caps_gl_ctx *ctx)
UINT64	adapter_adjust_memory (struct wined3d_adapter *adapter, INT64 amount)
static void	wined3d_adapter_cleanup (struct wined3d_adapter *adapter)
ULONG CDECL	wined3d_incref (struct wined3d *wined3d)
ULONG CDECL	wined3d_decref (struct wined3d *wined3d)
static BOOL	test_arb_vs_offset_limit (const struct wined3d_gl_info *gl_info)
static BOOL	match_amd_r300_to_500 (const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
static BOOL	match_geforce5 (const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
static BOOL	match_apple (const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
static void	test_pbo_functionality (struct wined3d_gl_info *gl_info)
static BOOL	match_apple_intel (const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
static BOOL	match_apple_nonr500ati (const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
static BOOL	match_dx10_capable (const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
static BOOL	match_not_dx10_capable (const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
static BOOL	match_allows_spec_alpha (const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
static BOOL	match_broken_nv_clip (const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
static BOOL	match_fbo_tex_update (const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
static BOOL	match_broken_rgba16 (const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
static BOOL	match_fglrx (const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
static BOOL	match_r200 (const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
static BOOL	match_broken_arb_fog (const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
static BOOL	match_broken_viewport_subpixel_bits (const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
static void	quirk_apple_glsl_constants (struct wined3d_gl_info *gl_info)
static void	quirk_amd_dx9 (struct wined3d_gl_info *gl_info)
static void	quirk_no_np2 (struct wined3d_gl_info *gl_info)
static void	quirk_texcoord_w (struct wined3d_gl_info *gl_info)
static void	quirk_clip_varying (struct wined3d_gl_info *gl_info)
static void	quirk_allows_specular_alpha (struct wined3d_gl_info *gl_info)
static void	quirk_disable_nvvp_clip (struct wined3d_gl_info *gl_info)
static void	quirk_fbo_tex_update (struct wined3d_gl_info *gl_info)
static void	quirk_broken_rgba16 (struct wined3d_gl_info *gl_info)
static void	quirk_infolog_spam (struct wined3d_gl_info *gl_info)
static void	quirk_limited_tex_filtering (struct wined3d_gl_info *gl_info)
static void	quirk_r200_constants (struct wined3d_gl_info *gl_info)
static void	quirk_broken_arb_fog (struct wined3d_gl_info *gl_info)
static void	quirk_broken_viewport_subpixel_bits (struct wined3d_gl_info *gl_info)
static const struct driver_version_information *	get_driver_version_info (enum wined3d_display_driver driver, enum wined3d_driver_model driver_model)
static const struct gpu_description *	get_gpu_description (enum wined3d_pci_vendor vendor, enum wined3d_pci_device device)
static const struct gpu_description *	query_gpu_description (const struct wined3d_gl_info *gl_info, UINT64 *vram_bytes)
static void	init_driver_info (struct wined3d_driver_info *driver_info, const struct gpu_description *gpu_desc, UINT64 vram_bytes)
static void	fixup_extensions (struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
static DWORD	wined3d_parse_gl_version (const char *gl_version)
static enum wined3d_gl_vendor	wined3d_guess_gl_vendor (const struct wined3d_gl_info *gl_info, const char *gl_vendor_string, const char *gl_renderer, const char *gl_version)
static enum wined3d_pci_vendor	wined3d_guess_card_vendor (const char *gl_vendor_string, const char *gl_renderer)
static enum wined3d_d3d_level	d3d_level_from_caps (const struct shader_caps *shader_caps, const struct fragment_caps *fragment_caps, DWORD glsl_version)
	C_ASSERT (ARRAY_SIZE(card_fallback_nvidia)==WINED3D_D3D_LEVEL_COUNT)
	C_ASSERT (ARRAY_SIZE(card_fallback_amd)==WINED3D_D3D_LEVEL_COUNT)
	C_ASSERT (ARRAY_SIZE(card_fallback_intel)==WINED3D_D3D_LEVEL_COUNT)
static enum wined3d_pci_device	select_card_handler (const struct gl_vendor_selection *table, unsigned int table_size, enum wined3d_gl_vendor gl_vendor, const char *gl_renderer)
static enum wined3d_pci_device	wined3d_guess_card (const struct shader_caps *shader_caps, const struct fragment_caps *fragment_caps, DWORD glsl_version, const char *gl_renderer, enum wined3d_gl_vendor *gl_vendor, enum wined3d_pci_vendor *card_vendor)
static const struct wined3d_vertex_pipe_ops *	select_vertex_implementation (const struct wined3d_gl_info *gl_info, const struct wined3d_shader_backend_ops *shader_backend_ops)
static const struct fragment_pipeline *	select_fragment_implementation (const struct wined3d_gl_info *gl_info, const struct wined3d_shader_backend_ops *shader_backend_ops)
static const struct wined3d_shader_backend_ops *	select_shader_backend (const struct wined3d_gl_info *gl_info)
static void	parse_extension_string (struct wined3d_gl_info *gl_info, const char *extensions, const struct wined3d_extension_map *map, UINT entry_count)
static void	enumerate_gl_extensions (struct wined3d_gl_info *gl_info, const struct wined3d_extension_map *map, unsigned int map_entries_count)
static void	load_gl_funcs (struct wined3d_gl_info *gl_info)
static void	wined3d_adapter_init_limits (struct wined3d_gl_info *gl_info)
static BOOL	wined3d_adapter_init_gl_caps (struct wined3d_adapter *adapter, struct wined3d_caps_gl_ctx *caps_gl_ctx, DWORD wined3d_creation_flags)
UINT CDECL	wined3d_get_adapter_count (const struct wined3d *wined3d)
HRESULT CDECL	wined3d_register_software_device (struct wined3d *wined3d, void *init_function)
HRESULT CDECL	wined3d_get_output_desc (const struct wined3d *wined3d, unsigned int adapter_idx, struct wined3d_output_desc *desc)
UINT CDECL	wined3d_get_adapter_mode_count (const struct wined3d *wined3d, UINT adapter_idx, enum wined3d_format_id format_id, enum wined3d_scanline_ordering scanline_ordering)
HRESULT CDECL	wined3d_enum_adapter_modes (const struct wined3d *wined3d, UINT adapter_idx, enum wined3d_format_id format_id, enum wined3d_scanline_ordering scanline_ordering, UINT mode_idx, struct wined3d_display_mode *mode)
HRESULT CDECL	wined3d_find_closest_matching_adapter_mode (const struct wined3d *wined3d, unsigned int adapter_idx, struct wined3d_display_mode *mode)
HRESULT CDECL	wined3d_get_adapter_display_mode (const struct wined3d *wined3d, UINT adapter_idx, struct wined3d_display_mode *mode, enum wined3d_display_rotation *rotation)
HRESULT CDECL	wined3d_set_adapter_display_mode (struct wined3d *wined3d, UINT adapter_idx, const struct wined3d_display_mode *mode)
HRESULT CDECL	wined3d_get_adapter_identifier (const struct wined3d *wined3d, UINT adapter_idx, DWORD flags, struct wined3d_adapter_identifier *identifier)
HRESULT CDECL	wined3d_get_adapter_raster_status (const struct wined3d *wined3d, UINT adapter_idx, struct wined3d_raster_status *raster_status)
static BOOL	wined3d_check_pixel_format_color (const struct wined3d_gl_info *gl_info, const struct wined3d_pixel_format *cfg, const struct wined3d_format *format)
static BOOL	wined3d_check_pixel_format_depth (const struct wined3d_gl_info *gl_info, const struct wined3d_pixel_format *cfg, const struct wined3d_format *format)
HRESULT CDECL	wined3d_check_depth_stencil_match (const struct wined3d *wined3d, UINT adapter_idx, enum wined3d_device_type device_type, enum wined3d_format_id adapter_format_id, enum wined3d_format_id render_target_format_id, enum wined3d_format_id depth_stencil_format_id)
HRESULT CDECL	wined3d_check_device_multisample_type (const struct wined3d *wined3d, UINT adapter_idx, enum wined3d_device_type device_type, enum wined3d_format_id surface_format_id, BOOL windowed, enum wined3d_multisample_type multisample_type, DWORD *quality_levels)
static BOOL	CheckDepthStencilCapability (const struct wined3d_adapter *adapter, const struct wined3d_format *display_format, const struct wined3d_format *ds_format, enum wined3d_gl_resource_type gl_type)
static BOOL	CheckRenderTargetCapability (const struct wined3d_adapter *adapter, const struct wined3d_format *adapter_format, const struct wined3d_format *check_format, enum wined3d_gl_resource_type gl_type)
static BOOL	wined3d_check_surface_capability (const struct wined3d_format *format, BOOL no3d)
HRESULT CDECL	wined3d_check_device_format (const struct wined3d *wined3d, UINT adapter_idx, enum wined3d_device_type device_type, enum wined3d_format_id adapter_format_id, DWORD usage, enum wined3d_resource_type resource_type, enum wined3d_format_id check_format_id)
UINT CDECL	wined3d_calculate_format_pitch (const struct wined3d *wined3d, UINT adapter_idx, enum wined3d_format_id format_id, UINT width)
HRESULT CDECL	wined3d_check_device_format_conversion (const struct wined3d *wined3d, UINT adapter_idx, enum wined3d_device_type device_type, enum wined3d_format_id src_format, enum wined3d_format_id dst_format)
HRESULT CDECL	wined3d_check_device_type (const struct wined3d *wined3d, UINT adapter_idx, enum wined3d_device_type device_type, enum wined3d_format_id display_format, enum wined3d_format_id backbuffer_format, BOOL windowed)
HRESULT CDECL	wined3d_get_device_caps (const struct wined3d *wined3d, UINT adapter_idx, enum wined3d_device_type device_type, WINED3DCAPS *caps)
HRESULT CDECL	wined3d_device_create (struct wined3d *wined3d, UINT adapter_idx, enum wined3d_device_type device_type, HWND focus_window, DWORD flags, BYTE surface_alignment, struct wined3d_device_parent *device_parent, struct wined3d_device **device)
static void WINE_GLAPI	invalid_func (const void *data)
static void WINE_GLAPI	invalid_texcoord_func (GLenum unit, const void *data)
static void WINE_GLAPI	invalid_generic_attrib_func (GLuint idx, const void *data)
static void WINE_GLAPI	position_d3dcolor (const void *data)
static void WINE_GLAPI	position_float4 (const void *data)
static void WINE_GLAPI	diffuse_d3dcolor (const void *data)
static void WINE_GLAPI	specular_d3dcolor (const void *data)
static void WINE_GLAPI	warn_no_specular_func (const void *data)
static void WINE_GLAPI	generic_d3dcolor (GLuint idx, const void *data)
static void WINE_GLAPI	generic_short2n (GLuint idx, const void *data)
static void WINE_GLAPI	generic_ushort2n (GLuint idx, const void *data)
static void WINE_GLAPI	generic_float16_2 (GLuint idx, const void *data)
static void WINE_GLAPI	generic_float16_4 (GLuint idx, const void *data)
static void	wined3d_adapter_init_ffp_attrib_ops (struct wined3d_adapter *adapter)
static void	wined3d_adapter_init_fb_cfgs (struct wined3d_adapter *adapter, HDC dc)
static DWORD	get_max_gl_version (const struct wined3d_gl_info *gl_info, DWORD flags)
static BOOL	has_extension (const char *list, const char *ext)
static BOOL	wined3d_adapter_init (struct wined3d_adapter *adapter, UINT ordinal, DWORD wined3d_creation_flags)
static BOOL	wined3d_adapter_init_nogl (struct wined3d_adapter *adapter, UINT ordinal)
static void STDMETHODCALLTYPE	wined3d_null_wined3d_object_destroyed (void *parent)
HRESULT	wined3d_init (struct wined3d *wined3d, DWORD flags)

Variables
static const GUID	IID_D3DDEVICE_D3DUID = { 0xaeb2cdd4, 0x6e41, 0x43ea, { 0x94,0x1c,0x83,0x61,0xcc,0x76,0x07,0x81 } }
static const struct wined3d_extension_map	gl_extension_map []
static const struct wined3d_extension_map	wgl_extension_map []
const struct min_lookup	minMipLookup []
const GLenum	magLookup []
static const struct driver_quirk	quirk_table []
static const struct driver_version_information	driver_version_table []
static const struct gpu_description	gpu_description_table []
static const struct wined3d_renderer_table	cards_nvidia_binary []
static const struct wined3d_renderer_table	cards_amd_binary []
static const struct wined3d_renderer_table	cards_intel []
static const struct wined3d_renderer_table	cards_amd_mesa []
static const struct wined3d_renderer_table	cards_nvidia_mesa []
static const struct wined3d_renderer_table	cards_vmware []
static const struct gl_vendor_selection	amd_gl_vendor_table []
static const struct gl_vendor_selection	nvidia_gl_vendor_table []
static const struct gl_vendor_selection	vmware_gl_vendor_table []
static const struct gl_vendor_selection	intel_gl_vendor_table []
static enum wined3d_pci_device	card_fallback_nvidia []
static enum wined3d_pci_device	card_fallback_amd []
static enum wined3d_pci_device	card_fallback_intel []
struct {
enum wined3d_pci_vendor   card_vendor
const char *   description
const struct gl_vendor_selection *   gl_vendor_selection
unsigned int   gl_vendor_count
enum wined3d_pci_device *   card_fallback
}	card_vendor_table []
const struct wined3d_parent_ops	wined3d_null_parent_ops

Macro Definition Documentation

DEFAULT_REFRESH_RATE

#define DEFAULT_REFRESH_RATE   0

Definition at line 36 of file directx.c.

MAP_GL_FUNCTION

#define MAP_GL_FUNCTION	(		core_func,
			ext_func
	)

Value:

do                                                                            \
        {                                                                             \
            if (!gl_info->gl_ops.ext.p_##core_func)                                   \
                gl_info->gl_ops.ext.p_##core_func = gl_info->gl_ops.ext.p_##ext_func; \
        } while (0)

MAP_GL_FUNCTION_CAST

#define MAP_GL_FUNCTION_CAST	(		core_func,
			ext_func
	)

Value:

do                                                                                    \
        {                                                                                     \
            if (!gl_info->gl_ops.ext.p_##core_func)                                           \
                gl_info->gl_ops.ext.p_##core_func = (void *)gl_info->gl_ops.ext.p_##ext_func; \
        } while (0)

USE_GL_FUNC

#define USE_GL_FUNC

(

pfn

)

gl_info->gl_ops.ext.p_##pfn = (void *)wglGetProcAddress(#pfn);

Enumeration Type Documentation

wined3d_d3d_level

enum wined3d_d3d_level

Enumerator
WINED3D_D3D_LEVEL_5
WINED3D_D3D_LEVEL_6
WINED3D_D3D_LEVEL_7
WINED3D_D3D_LEVEL_8
WINED3D_D3D_LEVEL_9_SM2
WINED3D_D3D_LEVEL_9_SM3
WINED3D_D3D_LEVEL_10
WINED3D_D3D_LEVEL_11
WINED3D_D3D_LEVEL_COUNT

Definition at line 80 of file directx.c.

{
    WINED3D_D3D_LEVEL_5,
    WINED3D_D3D_LEVEL_6,
    WINED3D_D3D_LEVEL_7,
    WINED3D_D3D_LEVEL_8,
    WINED3D_D3D_LEVEL_9_SM2,
    WINED3D_D3D_LEVEL_9_SM3,
    WINED3D_D3D_LEVEL_10,
    WINED3D_D3D_LEVEL_11,
    WINED3D_D3D_LEVEL_COUNT
};

wined3d_display_driver

enum wined3d_display_driver

Enumerator
DRIVER_AMD_RAGE_128PRO
DRIVER_AMD_R100
DRIVER_AMD_R300
DRIVER_AMD_R600
DRIVER_AMD_RX
DRIVER_INTEL_GMA800
DRIVER_INTEL_GMA900
DRIVER_INTEL_GMA950
DRIVER_INTEL_GMA3000
DRIVER_INTEL_HD4000
DRIVER_NVIDIA_TNT
DRIVER_NVIDIA_GEFORCE2MX
DRIVER_NVIDIA_GEFORCEFX
DRIVER_NVIDIA_GEFORCE6
DRIVER_NVIDIA_GEFORCE8
DRIVER_VMWARE
DRIVER_UNKNOWN

Definition at line 41 of file directx.c.

{
    DRIVER_AMD_RAGE_128PRO,
    DRIVER_AMD_R100,
    DRIVER_AMD_R300,
    DRIVER_AMD_R600,
    DRIVER_AMD_RX,
    DRIVER_INTEL_GMA800,
    DRIVER_INTEL_GMA900,
    DRIVER_INTEL_GMA950,
    DRIVER_INTEL_GMA3000,
    DRIVER_INTEL_HD4000,
    DRIVER_NVIDIA_TNT,
    DRIVER_NVIDIA_GEFORCE2MX,
    DRIVER_NVIDIA_GEFORCEFX,
    DRIVER_NVIDIA_GEFORCE6,
    DRIVER_NVIDIA_GEFORCE8,
    DRIVER_VMWARE,
    DRIVER_UNKNOWN
};

wined3d_driver_model

enum wined3d_driver_model

Enumerator
DRIVER_MODEL_GENERIC
DRIVER_MODEL_WIN9X
DRIVER_MODEL_NT40
DRIVER_MODEL_NT5X
DRIVER_MODEL_NT6X

Definition at line 62 of file directx.c.

{
    DRIVER_MODEL_GENERIC,
    DRIVER_MODEL_WIN9X,
    DRIVER_MODEL_NT40,
    DRIVER_MODEL_NT5X,
    DRIVER_MODEL_NT6X
};

wined3d_gl_vendor

enum wined3d_gl_vendor

Enumerator
GL_VENDOR_UNKNOWN
GL_VENDOR_APPLE
GL_VENDOR_FGLRX
GL_VENDOR_MESA
GL_VENDOR_NVIDIA

Definition at line 71 of file directx.c.

{
    GL_VENDOR_UNKNOWN,
    GL_VENDOR_APPLE,
    GL_VENDOR_FGLRX,
    GL_VENDOR_MESA,
    GL_VENDOR_NVIDIA,
};

Function Documentation

adapter_adjust_memory()

UINT64 adapter_adjust_memory	(	struct wined3d_adapter *	adapter,
		INT64	amount
	)

Definition at line 441 of file directx.c.

{
    adapter->vram_bytes_used += amount;
    TRACE("Adjusted used adapter memory by 0x%s to 0x%s.\n",
            wine_dbgstr_longlong(amount),
            wine_dbgstr_longlong(adapter->vram_bytes_used));
    return adapter->vram_bytes_used;
}

Referenced by resource_cleanup(), and resource_init().

C_ASSERT() [1/3]

C_ASSERT

(

ARRAY_SIZE(card_fallback_nvidia)

= =WINED3D_D3D_LEVEL_COUNT

)

C_ASSERT() [2/3]

C_ASSERT

(

ARRAY_SIZE(card_fallback_amd)

= =WINED3D_D3D_LEVEL_COUNT

)

C_ASSERT() [3/3]

C_ASSERT

(

ARRAY_SIZE(card_fallback_intel)

= =WINED3D_D3D_LEVEL_COUNT

)

CheckDepthStencilCapability()

static BOOL CheckDepthStencilCapability ( const struct wined3d_adapter *  adapter, const struct wined3d_format *  display_format, const struct wined3d_format *  ds_format, enum wined3d_gl_resource_type  gl_type  )

static

Definition at line 5190 of file directx.c.

{
    /* Only allow depth/stencil formats */
    if (!(ds_format->depth_size || ds_format->stencil_size)) return FALSE;

    /* Blacklist formats not supported on Windows */
    switch (ds_format->id)
    {
        case WINED3DFMT_S1_UINT_D15_UNORM: /* Breaks the shadowvol2 dx7 sdk sample */
        case WINED3DFMT_S4X4_UINT_D24_UNORM:
            TRACE("[FAILED] - not supported on windows.\n");
            return FALSE;

        default:
            break;
    }

    if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
    {
        /* With FBOs WGL limitations do not apply, but the format needs to be FBO attachable */
        if (ds_format->flags[gl_type] & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
            return TRUE;
    }
    else
    {
        unsigned int i;

        /* Walk through all WGL pixel formats to find a match */
        for (i = 0; i < adapter->cfg_count; ++i)
        {
            const struct wined3d_pixel_format *cfg = &adapter->cfgs[i];
            if (wined3d_check_pixel_format_color(&adapter->gl_info, cfg, display_format)
                    && wined3d_check_pixel_format_depth(&adapter->gl_info, cfg, ds_format))
                return TRUE;
        }
    }

    return FALSE;
}

Referenced by wined3d_check_device_format().

CheckRenderTargetCapability()

static BOOL CheckRenderTargetCapability ( const struct wined3d_adapter *  adapter, const struct wined3d_format *  adapter_format, const struct wined3d_format *  check_format, enum wined3d_gl_resource_type  gl_type  )

static

Definition at line 5233 of file directx.c.

{
    /* Filter out non-RT formats */
    if (!(check_format->flags[gl_type] & WINED3DFMT_FLAG_RENDERTARGET))
        return FALSE;
    if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
        return TRUE;
    if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER)
    {
        const struct wined3d_pixel_format *cfgs = adapter->cfgs;
        unsigned int i;

        /* In backbuffer mode the front and backbuffer share the same WGL
         * pixelformat. The format must match in RGB, alpha is allowed to be
         * different. (Only the backbuffer can have alpha.) */
        if (adapter_format->red_size != check_format->red_size
                || adapter_format->green_size != check_format->green_size
                || adapter_format->blue_size != check_format->blue_size)
        {
            TRACE("[FAILED]\n");
            return FALSE;
        }

        /* Check if there is a WGL pixel format matching the requirements, the format should also be window
         * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
        for (i = 0; i < adapter->cfg_count; ++i)
        {
            if (cfgs[i].windowDrawable
                    && wined3d_check_pixel_format_color(&adapter->gl_info, &cfgs[i], check_format))
            {
                TRACE("Pixel format %d is compatible with format %s.\n",
                        cfgs[i].iPixelFormat, debug_d3dformat(check_format->id));
                return TRUE;
            }
        }
    }
    return FALSE;
}

Referenced by wined3d_check_device_format().

d3d_level_from_caps()

static enum wined3d_d3d_level d3d_level_from_caps ( const struct shader_caps *  shader_caps, const struct fragment_caps *  fragment_caps, DWORD  glsl_version  )

static

Definition at line 1869 of file directx.c.

{
    if (shader_caps->vs_version >= 5)
        return WINED3D_D3D_LEVEL_11;
    if (shader_caps->vs_version == 4)
        return WINED3D_D3D_LEVEL_10;
    if (shader_caps->vs_version == 3)
    {
        /* wined3d with default settings at the moment doesn't expose SM4+ on
         * Mesa drivers. */
        if (glsl_version >= MAKEDWORD_VERSION(4, 30))
            return WINED3D_D3D_LEVEL_11;
        if (glsl_version >= MAKEDWORD_VERSION(1, 30))
            return WINED3D_D3D_LEVEL_10;
        return WINED3D_D3D_LEVEL_9_SM3;
    }
    if (shader_caps->vs_version == 2)
        return WINED3D_D3D_LEVEL_9_SM2;
    if (shader_caps->vs_version == 1)
        return WINED3D_D3D_LEVEL_8;

    if (fragment_caps->TextureOpCaps & WINED3DTEXOPCAPS_DOTPRODUCT3)
        return WINED3D_D3D_LEVEL_7;
    if (fragment_caps->MaxSimultaneousTextures > 1)
        return WINED3D_D3D_LEVEL_6;

    return WINED3D_D3D_LEVEL_5;
}

Referenced by wined3d_guess_card().

diffuse_d3dcolor()

static void WINE_GLAPI diffuse_d3dcolor ( const void *  data )

static

Definition at line 6327 of file directx.c.

{
    DWORD diffuseColor = *((const DWORD *)data);

    context_get_current()->gl_info->gl_ops.gl.p_glColor4ub(D3DCOLOR_B_R(diffuseColor),
            D3DCOLOR_B_G(diffuseColor),
            D3DCOLOR_B_B(diffuseColor),
            D3DCOLOR_B_A(diffuseColor));
}

Referenced by wined3d_adapter_init_ffp_attrib_ops().

enumerate_gl_extensions()

static void enumerate_gl_extensions ( struct wined3d_gl_info *  gl_info, const struct wined3d_extension_map *  map, unsigned int  map_entries_count  )

static

Definition at line 2672 of file directx.c.

{
    const char *gl_extension_name;
    unsigned int i, j;
    GLint extensions_count;

    gl_info->gl_ops.gl.p_glGetIntegerv(GL_NUM_EXTENSIONS, &extensions_count);
    for (i = 0; i < extensions_count; ++i)
    {
        gl_extension_name = (const char *)GL_EXTCALL(glGetStringi(GL_EXTENSIONS, i));
        TRACE("- %s.\n", debugstr_a(gl_extension_name));
        for (j = 0; j < map_entries_count; ++j)
        {
            if (!strcmp(gl_extension_name, map[j].extension_string))
            {
                TRACE("FOUND: %s support.\n", map[j].extension_string);
                gl_info->supported[map[j].extension] = TRUE;
                break;
            }
        }
    }
}

Referenced by wined3d_adapter_init_gl_caps().

fixup_extensions()

static void fixup_extensions ( struct wined3d_gl_info *  gl_info, struct wined3d_caps_gl_ctx *  ctx, const char *  gl_renderer, enum wined3d_gl_vendor  gl_vendor, enum wined3d_pci_vendor  card_vendor, enum wined3d_pci_device  device  )

static

Definition at line 1748 of file directx.c.

{
    unsigned int i;

    for (i = 0; i < ARRAY_SIZE(quirk_table); ++i)
    {
        if (!quirk_table[i].match(gl_info, ctx, gl_renderer, gl_vendor, card_vendor, device)) continue;
        TRACE("Applying driver quirk \"%s\".\n", quirk_table[i].description);
        quirk_table[i].apply(gl_info);
    }

    /* Find out if PBOs work as they are supposed to. */
    test_pbo_functionality(gl_info);
}

Referenced by wined3d_adapter_init_gl_caps().

generic_d3dcolor()

static void WINE_GLAPI generic_d3dcolor ( GLuint  idx, const void *  data  )

static

Definition at line 6355 of file directx.c.

{
    DWORD color = *((const DWORD *)data);

    context_get_current()->gl_info->gl_ops.ext.p_glVertexAttrib4Nub(idx,
            D3DCOLOR_B_R(color), D3DCOLOR_B_G(color),
            D3DCOLOR_B_B(color), D3DCOLOR_B_A(color));
}

Referenced by wined3d_adapter_init_ffp_attrib_ops().

generic_float16_2()

static void WINE_GLAPI generic_float16_2 ( GLuint  idx, const void *  data  )

static

Definition at line 6378 of file directx.c.

{
    float x = float_16_to_32(((const unsigned short *)data) + 0);
    float y = float_16_to_32(((const unsigned short *)data) + 1);

    context_get_current()->gl_info->gl_ops.ext.p_glVertexAttrib2f(idx, x, y);
}

Referenced by wined3d_adapter_init_ffp_attrib_ops().

generic_float16_4()

static void WINE_GLAPI generic_float16_4 ( GLuint  idx, const void *  data  )

static

Definition at line 6386 of file directx.c.

{
    float x = float_16_to_32(((const unsigned short *)data) + 0);
    float y = float_16_to_32(((const unsigned short *)data) + 1);
    float z = float_16_to_32(((const unsigned short *)data) + 2);
    float w = float_16_to_32(((const unsigned short *)data) + 3);

    context_get_current()->gl_info->gl_ops.ext.p_glVertexAttrib4f(idx, x, y, z, w);
}

Referenced by wined3d_adapter_init_ffp_attrib_ops().

generic_short2n()

static void WINE_GLAPI generic_short2n ( GLuint  idx, const void *  data  )

static

Definition at line 6364 of file directx.c.

{
    const GLshort s[] = {((const GLshort *)data)[0], ((const GLshort *)data)[1], 0, 1};

    context_get_current()->gl_info->gl_ops.ext.p_glVertexAttrib4Nsv(idx, s);
}

Referenced by wined3d_adapter_init_ffp_attrib_ops().

generic_ushort2n()

static void WINE_GLAPI generic_ushort2n ( GLuint  idx, const void *  data  )

static

Definition at line 6371 of file directx.c.

{
    const GLushort s[] = {((const GLushort *)data)[0], ((const GLushort *)data)[1], 0, 1};

    context_get_current()->gl_info->gl_ops.ext.p_glVertexAttrib4Nusv(idx, s);
}

Referenced by wined3d_adapter_init_ffp_attrib_ops().

get_driver_version_info()

static const struct driver_version_information* get_driver_version_info ( enum wined3d_display_driver  driver, enum wined3d_driver_model  driver_model  )

static

Definition at line 1531 of file directx.c.

{
    unsigned int i;

    TRACE("Looking up version info for driver=%d driver_model=%d\n", driver, driver_model);
    for (i = 0; i < ARRAY_SIZE(driver_version_table); ++i)
    {
        const struct driver_version_information *entry = &driver_version_table[i];

        if (entry->driver == driver && (driver_model == DRIVER_MODEL_GENERIC
                || entry->driver_model == driver_model))
        {
            TRACE("Found driver \"%s\", version %u, subversion %u, build %u.\n",
                    entry->driver_name, entry->version, entry->subversion, entry->build);
            return entry;
        }
    }
    return NULL;
}

Referenced by init_driver_info().

get_gpu_description()

static const struct gpu_description* get_gpu_description ( enum wined3d_pci_vendor  vendor, enum wined3d_pci_device  device  )

static

Definition at line 1552 of file directx.c.

{
    unsigned int i;

    for (i = 0; i < ARRAY_SIZE(gpu_description_table); ++i)
    {
        if (vendor == gpu_description_table[i].vendor && device == gpu_description_table[i].card)
            return &gpu_description_table[i];
    }

    return NULL;
}

Referenced by query_gpu_description(), and wined3d_adapter_init_gl_caps().

get_max_gl_version()

static DWORD get_max_gl_version ( const struct wined3d_gl_info *  gl_info, DWORD  flags  )

static

Definition at line 6618 of file directx.c.

{
    const char *gl_vendor, *gl_renderer;

    if (wined3d_settings.explicit_gl_version || (flags & WINED3D_PIXEL_CENTER_INTEGER))
        return wined3d_settings.max_gl_version;

    gl_vendor = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_VENDOR);
    gl_renderer = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_RENDERER);
    if (!gl_vendor || !gl_renderer
            || wined3d_guess_card_vendor(gl_vendor, gl_renderer) == HW_VENDOR_NVIDIA)
        return wined3d_settings.max_gl_version;

    return MAKEDWORD_VERSION(4, 4);
}

Referenced by wined3d_adapter_init().

has_extension()

static BOOL has_extension ( const char *  list, const char *  ext  )

static

Definition at line 6634 of file directx.c.

{
    size_t len = strlen(ext);
    while (list)
    {
        while (*list == ' ') list++;
        if (!strncmp(list, ext, len) && (!list[len] || list[len] == ' ')) return TRUE;
        list = strchr(list, ' ');
    }
    return FALSE;
}

Referenced by wined3d_adapter_init().

init_driver_info()

static void init_driver_info ( struct wined3d_driver_info *  driver_info, const struct gpu_description *  gpu_desc, UINT64  vram_bytes  )

static

Diablo 2 crashes when the amount of video memory is greater than 0x7fffffff. In order to avoid this application bug we limit the amount of video memory to LONG_MAX for older Windows versions.

Definition at line 1623 of file directx.c.

{
    OSVERSIONINFOW os_version;
    WORD driver_os_version;
    enum wined3d_display_driver driver;
    enum wined3d_driver_model driver_model;
    const struct driver_version_information *version_info;

    memset(&os_version, 0, sizeof(os_version));
    os_version.dwOSVersionInfoSize = sizeof(os_version);
    if (!GetVersionExW(&os_version))
    {
        ERR("Failed to get OS version, reporting 2000/XP.\n");
        driver_os_version = 6;
        driver_model = DRIVER_MODEL_NT5X;
    }
    else
    {
        TRACE("OS version %u.%u.\n", os_version.dwMajorVersion, os_version.dwMinorVersion);
        switch (os_version.dwMajorVersion)
        {
            case 4:
                /* If needed we could distinguish between 9x and NT4, but this code won't make
                 * sense for NT4 since it had no way to obtain this info through DirectDraw 3.0.
                 */
                driver_os_version = 4;
                driver_model = DRIVER_MODEL_WIN9X;
                break;

            case 5:
                driver_os_version = 6;
                driver_model = DRIVER_MODEL_NT5X;
                break;

            case 6:
                if (os_version.dwMinorVersion == 0)
                {
                    driver_os_version = 7;
                    driver_model = DRIVER_MODEL_NT6X;
                }
                else if (os_version.dwMinorVersion == 1)
                {
                    driver_os_version = 8;
                    driver_model = DRIVER_MODEL_NT6X;
                }
                else
                {
                    if (os_version.dwMinorVersion > 2)
                    {
                        FIXME("Unhandled OS version %u.%u, reporting Win 8.\n",
                                os_version.dwMajorVersion, os_version.dwMinorVersion);
                    }
                    driver_os_version = 9;
                    driver_model = DRIVER_MODEL_NT6X;
                }
                break;

            case 10:
                driver_os_version = 10;
                driver_model = DRIVER_MODEL_NT6X;
                break;

            default:
                FIXME("Unhandled OS version %u.%u, reporting 2000/XP.\n",
                        os_version.dwMajorVersion, os_version.dwMinorVersion);
                driver_os_version = 6;
                driver_model = DRIVER_MODEL_NT5X;
                break;
        }
    }

    driver_info->vendor = gpu_desc->vendor;
    driver_info->device = gpu_desc->card;
    driver_info->description = gpu_desc->description;
    driver_info->vram_bytes = vram_bytes ? vram_bytes : (UINT64)gpu_desc->vidmem * 1024 * 1024;
    driver = gpu_desc->driver;

#ifdef __i386__
    if (driver_model < DRIVER_MODEL_NT6X && driver_info->vram_bytes > LONG_MAX)
    {
        TRACE("Limiting amount of video memory to %#lx bytes for OS version older than Vista.\n", LONG_MAX);
        driver_info->vram_bytes = LONG_MAX;
    }
#endif

    /* Try to obtain driver version information for the current Windows version. This fails in
     * some cases:
     * - the gpu is not available on the currently selected OS version:
     *   - Geforce GTX480 on Win98. When running applications in compatibility mode on Windows,
     *     version information for the current Windows version is returned instead of faked info.
     *     We do the same and assume the default Windows version to emulate is WinXP.
     *
     *   - Videocard is a Riva TNT but winver is set to win7 (there are no drivers for this beast)
     *     For now return the XP driver info. Perhaps later on we should return VESA.
     *
     * - the gpu is not in our database (can happen when the user overrides the vendor_id / device_id)
     *   This could be an indication that our database is not up to date, so this should be fixed.
     */
    if ((version_info = get_driver_version_info(driver, driver_model))
            || (version_info = get_driver_version_info(driver, DRIVER_MODEL_GENERIC)))
    {
        driver_info->name = version_info->driver_name;
        driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, version_info->version);
        driver_info->version_low = MAKEDWORD_VERSION(version_info->subversion, version_info->build);
    }
    else
    {
        ERR("No driver version info found for device %04x:%04x, driver model %#x.\n",
                driver_info->vendor, driver_info->device, driver_model);
        driver_info->name = "Display";
        driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, 15);
        driver_info->version_low = MAKEDWORD_VERSION(8, 6); /* Nvidia RIVA TNT, arbitrary */
    }

    TRACE("Reporting (fake) driver version 0x%08x-0x%08x.\n",
            driver_info->version_high, driver_info->version_low);
}

Referenced by wined3d_adapter_init_gl_caps().

invalid_func()

static void WINE_GLAPI invalid_func ( const void *  data )

static

Definition at line 6279 of file directx.c.

{
    ERR("Invalid vertex attribute function called.\n");
    DebugBreak();
}

Referenced by wined3d_adapter_init_ffp_attrib_ops().

invalid_generic_attrib_func()

static void WINE_GLAPI invalid_generic_attrib_func ( GLuint  idx, const void *  data  )

static

Definition at line 6291 of file directx.c.

{
    ERR("Invalid attribute function called.\n");
    DebugBreak();
}

Referenced by wined3d_adapter_init_ffp_attrib_ops().

invalid_texcoord_func()

static void WINE_GLAPI invalid_texcoord_func ( GLenum  unit, const void *  data  )

static

Definition at line 6285 of file directx.c.

{
    ERR("Invalid texcoord function called.\n");
    DebugBreak();
}

Referenced by wined3d_adapter_init_ffp_attrib_ops().

load_gl_funcs()

static void load_gl_funcs ( struct wined3d_gl_info *  gl_info )

static

Definition at line 2696 of file directx.c.

{
#define USE_GL_FUNC(pfn) gl_info->gl_ops.ext.p_##pfn = (void *)wglGetProcAddress(#pfn);
    /* GL_APPLE_fence */
    USE_GL_FUNC(glDeleteFencesAPPLE)
    USE_GL_FUNC(glFinishFenceAPPLE)
    USE_GL_FUNC(glFinishObjectAPPLE)
    USE_GL_FUNC(glGenFencesAPPLE)
    USE_GL_FUNC(glIsFenceAPPLE)
    USE_GL_FUNC(glSetFenceAPPLE)
    USE_GL_FUNC(glTestFenceAPPLE)
    USE_GL_FUNC(glTestObjectAPPLE)
    /* GL_APPLE_flush_buffer_range */
    USE_GL_FUNC(glBufferParameteriAPPLE)
    USE_GL_FUNC(glFlushMappedBufferRangeAPPLE)
    /* GL_ARB_base_instance */
    USE_GL_FUNC(glDrawArraysInstancedBaseInstance)
    USE_GL_FUNC(glDrawElementsInstancedBaseVertexBaseInstance)
    /* GL_ARB_blend_func_extended */
    USE_GL_FUNC(glBindFragDataLocationIndexed)
    USE_GL_FUNC(glGetFragDataIndex)
    /* GL_ARB_clear_buffer_object */
    USE_GL_FUNC(glClearBufferData)
    USE_GL_FUNC(glClearBufferSubData)
    /* GL_ARB_clear_texture */
    USE_GL_FUNC(glClearTexImage)
    USE_GL_FUNC(glClearTexSubImage)
    /* GL_ARB_clip_control */
    USE_GL_FUNC(glClipControl)
    /* GL_ARB_color_buffer_float */
    USE_GL_FUNC(glClampColorARB)
    /* GL_ARB_compute_shader */
    USE_GL_FUNC(glDispatchCompute)
    USE_GL_FUNC(glDispatchComputeIndirect)
    /* GL_ARB_copy_buffer */
    USE_GL_FUNC(glCopyBufferSubData)
    /* GL_ARB_copy_image */
    USE_GL_FUNC(glCopyImageSubData)
    /* GL_ARB_debug_output */
    USE_GL_FUNC(glDebugMessageCallbackARB)
    USE_GL_FUNC(glDebugMessageControlARB)
    USE_GL_FUNC(glDebugMessageInsertARB)
    USE_GL_FUNC(glGetDebugMessageLogARB)
    /* GL_ARB_draw_buffers */
    USE_GL_FUNC(glDrawBuffersARB)
    /* GL_ARB_draw_elements_base_vertex */
    USE_GL_FUNC(glDrawElementsBaseVertex)
    USE_GL_FUNC(glDrawElementsInstancedBaseVertex)
    USE_GL_FUNC(glDrawRangeElementsBaseVertex)
    USE_GL_FUNC(glMultiDrawElementsBaseVertex)
    /* GL_ARB_draw_indirect */
    USE_GL_FUNC(glDrawArraysIndirect)
    USE_GL_FUNC(glDrawElementsIndirect)
    /* GL_ARB_draw_instanced */
    USE_GL_FUNC(glDrawArraysInstancedARB)
    USE_GL_FUNC(glDrawElementsInstancedARB)
    /* GL_ARB_ES2_compatibility */
    USE_GL_FUNC(glReleaseShaderCompiler)
    USE_GL_FUNC(glShaderBinary)
    USE_GL_FUNC(glGetShaderPrecisionFormat)
    USE_GL_FUNC(glDepthRangef)
    USE_GL_FUNC(glClearDepthf)
    /* GL_ARB_framebuffer_no_attachments */
    USE_GL_FUNC(glFramebufferParameteri)
    /* GL_ARB_framebuffer_object */
    USE_GL_FUNC(glBindFramebuffer)
    USE_GL_FUNC(glBindRenderbuffer)
    USE_GL_FUNC(glBlitFramebuffer)
    USE_GL_FUNC(glCheckFramebufferStatus)
    USE_GL_FUNC(glDeleteFramebuffers)
    USE_GL_FUNC(glDeleteRenderbuffers)
    USE_GL_FUNC(glFramebufferRenderbuffer)
    USE_GL_FUNC(glFramebufferTexture)
    USE_GL_FUNC(glFramebufferTexture1D)
    USE_GL_FUNC(glFramebufferTexture2D)
    USE_GL_FUNC(glFramebufferTexture3D)
    USE_GL_FUNC(glFramebufferTextureLayer)
    USE_GL_FUNC(glGenFramebuffers)
    USE_GL_FUNC(glGenRenderbuffers)
    USE_GL_FUNC(glGenerateMipmap)
    USE_GL_FUNC(glGetFramebufferAttachmentParameteriv)
    USE_GL_FUNC(glGetRenderbufferParameteriv)
    USE_GL_FUNC(glIsFramebuffer)
    USE_GL_FUNC(glIsRenderbuffer)
    USE_GL_FUNC(glRenderbufferStorage)
    USE_GL_FUNC(glRenderbufferStorageMultisample)
    /* GL_ARB_geometry_shader4 */
    USE_GL_FUNC(glFramebufferTextureARB)
    USE_GL_FUNC(glFramebufferTextureFaceARB)
    USE_GL_FUNC(glFramebufferTextureLayerARB)
    USE_GL_FUNC(glProgramParameteriARB)
    /* GL_ARB_instanced_arrays */
    USE_GL_FUNC(glVertexAttribDivisorARB)
    /* GL_ARB_internalformat_query */
    USE_GL_FUNC(glGetInternalformativ)
    /* GL_ARB_internalformat_query2 */
    USE_GL_FUNC(glGetInternalformati64v)
    /* GL_ARB_map_buffer_range */
    USE_GL_FUNC(glFlushMappedBufferRange)
    USE_GL_FUNC(glMapBufferRange)
    /* GL_ARB_multisample */
    USE_GL_FUNC(glSampleCoverageARB)
    /* GL_ARB_multitexture */
    USE_GL_FUNC(glActiveTextureARB)
    USE_GL_FUNC(glClientActiveTextureARB)
    USE_GL_FUNC(glMultiTexCoord1fARB)
    USE_GL_FUNC(glMultiTexCoord1fvARB)
    USE_GL_FUNC(glMultiTexCoord2fARB)
    USE_GL_FUNC(glMultiTexCoord2fvARB)
    USE_GL_FUNC(glMultiTexCoord2svARB)
    USE_GL_FUNC(glMultiTexCoord3fARB)
    USE_GL_FUNC(glMultiTexCoord3fvARB)
    USE_GL_FUNC(glMultiTexCoord4fARB)
    USE_GL_FUNC(glMultiTexCoord4fvARB)
    USE_GL_FUNC(glMultiTexCoord4svARB)
    /* GL_ARB_occlusion_query */
    USE_GL_FUNC(glBeginQueryARB)
    USE_GL_FUNC(glDeleteQueriesARB)
    USE_GL_FUNC(glEndQueryARB)
    USE_GL_FUNC(glGenQueriesARB)
    USE_GL_FUNC(glGetQueryivARB)
    USE_GL_FUNC(glGetQueryObjectivARB)
    USE_GL_FUNC(glGetQueryObjectuivARB)
    USE_GL_FUNC(glIsQueryARB)
    /* GL_ARB_point_parameters */
    USE_GL_FUNC(glPointParameterfARB)
    USE_GL_FUNC(glPointParameterfvARB)
    /* GL_ARB_provoking_vertex */
    USE_GL_FUNC(glProvokingVertex)
    /* GL_ARB_sampler_objects */
    USE_GL_FUNC(glGenSamplers)
    USE_GL_FUNC(glDeleteSamplers)
    USE_GL_FUNC(glIsSampler)
    USE_GL_FUNC(glBindSampler)
    USE_GL_FUNC(glSamplerParameteri)
    USE_GL_FUNC(glSamplerParameterf)
    USE_GL_FUNC(glSamplerParameteriv)
    USE_GL_FUNC(glSamplerParameterfv)
    USE_GL_FUNC(glSamplerParameterIiv)
    USE_GL_FUNC(glSamplerParameterIuiv)
    USE_GL_FUNC(glGetSamplerParameteriv)
    USE_GL_FUNC(glGetSamplerParameterfv)
    USE_GL_FUNC(glGetSamplerParameterIiv)
    USE_GL_FUNC(glGetSamplerParameterIuiv)
    /* GL_ARB_shader_atomic_counters */
    USE_GL_FUNC(glGetActiveAtomicCounterBufferiv)
    /* GL_ARB_shader_image_load_store */
    USE_GL_FUNC(glBindImageTexture)
    USE_GL_FUNC(glMemoryBarrier)
    /* GL_ARB_shader_objects */
    USE_GL_FUNC(glAttachObjectARB)
    USE_GL_FUNC(glBindAttribLocationARB)
    USE_GL_FUNC(glCompileShaderARB)
    USE_GL_FUNC(glCreateProgramObjectARB)
    USE_GL_FUNC(glCreateShaderObjectARB)
    USE_GL_FUNC(glDeleteObjectARB)
    USE_GL_FUNC(glDetachObjectARB)
    USE_GL_FUNC(glGetActiveUniformARB)
    USE_GL_FUNC(glGetAttachedObjectsARB)
    USE_GL_FUNC(glGetAttribLocationARB)
    USE_GL_FUNC(glGetHandleARB)
    USE_GL_FUNC(glGetInfoLogARB)
    USE_GL_FUNC(glGetObjectParameterfvARB)
    USE_GL_FUNC(glGetObjectParameterivARB)
    USE_GL_FUNC(glGetShaderSourceARB)
    USE_GL_FUNC(glGetUniformLocationARB)
    USE_GL_FUNC(glGetUniformfvARB)
    USE_GL_FUNC(glGetUniformivARB)
    USE_GL_FUNC(glLinkProgramARB)
    USE_GL_FUNC(glShaderSourceARB)
    USE_GL_FUNC(glUniform1fARB)
    USE_GL_FUNC(glUniform1fvARB)
    USE_GL_FUNC(glUniform1iARB)
    USE_GL_FUNC(glUniform1ivARB)
    USE_GL_FUNC(glUniform2fARB)
    USE_GL_FUNC(glUniform2fvARB)
    USE_GL_FUNC(glUniform2iARB)
    USE_GL_FUNC(glUniform2ivARB)
    USE_GL_FUNC(glUniform3fARB)
    USE_GL_FUNC(glUniform3fvARB)
    USE_GL_FUNC(glUniform3iARB)
    USE_GL_FUNC(glUniform3ivARB)
    USE_GL_FUNC(glUniform4fARB)
    USE_GL_FUNC(glUniform4fvARB)
    USE_GL_FUNC(glUniform4iARB)
    USE_GL_FUNC(glUniform4ivARB)
    USE_GL_FUNC(glUniformMatrix2fvARB)
    USE_GL_FUNC(glUniformMatrix3fvARB)
    USE_GL_FUNC(glUniformMatrix4fvARB)
    USE_GL_FUNC(glUseProgramObjectARB)
    USE_GL_FUNC(glValidateProgramARB)
    /* GL_ARB_shader_storage_buffer_object */
    USE_GL_FUNC(glShaderStorageBlockBinding)
    /* GL_ARB_sync */
    USE_GL_FUNC(glClientWaitSync)
    USE_GL_FUNC(glDeleteSync)
    USE_GL_FUNC(glFenceSync)
    USE_GL_FUNC(glGetInteger64v)
    USE_GL_FUNC(glGetSynciv)
    USE_GL_FUNC(glIsSync)
    USE_GL_FUNC(glWaitSync)
    /* GL_ARB_tessellation_shader */
    USE_GL_FUNC(glPatchParameteri)
    USE_GL_FUNC(glPatchParameterfv)
    /* GL_ARB_texture_buffer_object */
    USE_GL_FUNC(glTexBufferARB)
    /* GL_ARB_texture_buffer_range */
    USE_GL_FUNC(glTexBufferRange)
    /* GL_ARB_texture_compression */
    USE_GL_FUNC(glCompressedTexImage2DARB)
    USE_GL_FUNC(glCompressedTexImage3DARB)
    USE_GL_FUNC(glCompressedTexSubImage2DARB)
    USE_GL_FUNC(glCompressedTexSubImage3DARB)
    USE_GL_FUNC(glGetCompressedTexImageARB)
    /* GL_ARB_texture_multisample */
    USE_GL_FUNC(glGetMultisamplefv);
    USE_GL_FUNC(glSampleMaski);
    USE_GL_FUNC(glTexImage2DMultisample);
    USE_GL_FUNC(glTexImage3DMultisample);
    /* GL_ARB_texture_storage */
    USE_GL_FUNC(glTexStorage1D)
    USE_GL_FUNC(glTexStorage2D)
    USE_GL_FUNC(glTexStorage3D)
    /* GL_ARB_texture_storage_multisample */
    USE_GL_FUNC(glTexStorage2DMultisample);
    USE_GL_FUNC(glTexStorage3DMultisample);
    /* GL_ARB_texture_view */
    USE_GL_FUNC(glTextureView)
    /* GL_ARB_timer_query */
    USE_GL_FUNC(glQueryCounter)
    USE_GL_FUNC(glGetQueryObjectui64v)
    /* GL_ARB_transform_feedback2 */
    USE_GL_FUNC(glBindTransformFeedback);
    USE_GL_FUNC(glDeleteTransformFeedbacks);
    USE_GL_FUNC(glDrawTransformFeedback);
    USE_GL_FUNC(glGenTransformFeedbacks);
    USE_GL_FUNC(glIsTransformFeedback);
    USE_GL_FUNC(glPauseTransformFeedback);
    USE_GL_FUNC(glResumeTransformFeedback);
    /* GL_ARB_transform_feedback3 */
    USE_GL_FUNC(glBeginQueryIndexed);
    USE_GL_FUNC(glDrawTransformFeedbackStream);
    USE_GL_FUNC(glEndQueryIndexed);
    USE_GL_FUNC(glGetQueryIndexediv);
    /* GL_ARB_uniform_buffer_object */
    USE_GL_FUNC(glBindBufferBase)
    USE_GL_FUNC(glBindBufferRange)
    USE_GL_FUNC(glGetActiveUniformBlockName)
    USE_GL_FUNC(glGetActiveUniformBlockiv)
    USE_GL_FUNC(glGetActiveUniformName)
    USE_GL_FUNC(glGetActiveUniformsiv)
    USE_GL_FUNC(glGetIntegeri_v)
    USE_GL_FUNC(glGetUniformBlockIndex)
    USE_GL_FUNC(glGetUniformIndices)
    USE_GL_FUNC(glUniformBlockBinding)
    /* GL_ARB_vertex_blend */
    USE_GL_FUNC(glVertexBlendARB)
    USE_GL_FUNC(glWeightPointerARB)
    USE_GL_FUNC(glWeightbvARB)
    USE_GL_FUNC(glWeightdvARB)
    USE_GL_FUNC(glWeightfvARB)
    USE_GL_FUNC(glWeightivARB)
    USE_GL_FUNC(glWeightsvARB)
    USE_GL_FUNC(glWeightubvARB)
    USE_GL_FUNC(glWeightuivARB)
    USE_GL_FUNC(glWeightusvARB)
    /* GL_ARB_vertex_buffer_object */
    USE_GL_FUNC(glBindBufferARB)
    USE_GL_FUNC(glBufferDataARB)
    USE_GL_FUNC(glBufferSubDataARB)
    USE_GL_FUNC(glDeleteBuffersARB)
    USE_GL_FUNC(glGenBuffersARB)
    USE_GL_FUNC(glGetBufferParameterivARB)
    USE_GL_FUNC(glGetBufferPointervARB)
    USE_GL_FUNC(glGetBufferSubDataARB)
    USE_GL_FUNC(glIsBufferARB)
    USE_GL_FUNC(glMapBufferARB)
    USE_GL_FUNC(glUnmapBufferARB)
    /* GL_ARB_vertex_program */
    USE_GL_FUNC(glBindProgramARB)
    USE_GL_FUNC(glDeleteProgramsARB)
    USE_GL_FUNC(glDisableVertexAttribArrayARB)
    USE_GL_FUNC(glEnableVertexAttribArrayARB)
    USE_GL_FUNC(glGenProgramsARB)
    USE_GL_FUNC(glGetProgramivARB)
    USE_GL_FUNC(glProgramEnvParameter4fvARB)
    USE_GL_FUNC(glProgramLocalParameter4fvARB)
    USE_GL_FUNC(glProgramStringARB)
    USE_GL_FUNC(glVertexAttrib1dARB)
    USE_GL_FUNC(glVertexAttrib1dvARB)
    USE_GL_FUNC(glVertexAttrib1fARB)
    USE_GL_FUNC(glVertexAttrib1fvARB)
    USE_GL_FUNC(glVertexAttrib1sARB)
    USE_GL_FUNC(glVertexAttrib1svARB)
    USE_GL_FUNC(glVertexAttrib2dARB)
    USE_GL_FUNC(glVertexAttrib2dvARB)
    USE_GL_FUNC(glVertexAttrib2fARB)
    USE_GL_FUNC(glVertexAttrib2fvARB)
    USE_GL_FUNC(glVertexAttrib2sARB)
    USE_GL_FUNC(glVertexAttrib2svARB)
    USE_GL_FUNC(glVertexAttrib3dARB)
    USE_GL_FUNC(glVertexAttrib3dvARB)
    USE_GL_FUNC(glVertexAttrib3fARB)
    USE_GL_FUNC(glVertexAttrib3fvARB)
    USE_GL_FUNC(glVertexAttrib3sARB)
    USE_GL_FUNC(glVertexAttrib3svARB)
    USE_GL_FUNC(glVertexAttrib4NbvARB)
    USE_GL_FUNC(glVertexAttrib4NivARB)
    USE_GL_FUNC(glVertexAttrib4NsvARB)
    USE_GL_FUNC(glVertexAttrib4NubARB)
    USE_GL_FUNC(glVertexAttrib4NubvARB)
    USE_GL_FUNC(glVertexAttrib4NuivARB)
    USE_GL_FUNC(glVertexAttrib4NusvARB)
    USE_GL_FUNC(glVertexAttrib4bvARB)
    USE_GL_FUNC(glVertexAttrib4dARB)
    USE_GL_FUNC(glVertexAttrib4dvARB)
    USE_GL_FUNC(glVertexAttrib4fARB)
    USE_GL_FUNC(glVertexAttrib4fvARB)
    USE_GL_FUNC(glVertexAttrib4ivARB)
    USE_GL_FUNC(glVertexAttrib4sARB)
    USE_GL_FUNC(glVertexAttrib4svARB)
    USE_GL_FUNC(glVertexAttrib4ubvARB)
    USE_GL_FUNC(glVertexAttrib4uivARB)
    USE_GL_FUNC(glVertexAttrib4usvARB)
    USE_GL_FUNC(glVertexAttribPointerARB)
    /* GL_ARB_viewport_array */
    USE_GL_FUNC(glDepthRangeArrayv)
    USE_GL_FUNC(glDepthRangeIndexed)
    USE_GL_FUNC(glGetDoublei_v)
    USE_GL_FUNC(glGetFloati_v)
    USE_GL_FUNC(glScissorArrayv)
    USE_GL_FUNC(glScissorIndexed)
    USE_GL_FUNC(glScissorIndexedv)
    USE_GL_FUNC(glViewportArrayv)
    USE_GL_FUNC(glViewportIndexedf)
    USE_GL_FUNC(glViewportIndexedfv)
    /* GL_ATI_fragment_shader */
    USE_GL_FUNC(glAlphaFragmentOp1ATI)
    USE_GL_FUNC(glAlphaFragmentOp2ATI)
    USE_GL_FUNC(glAlphaFragmentOp3ATI)
    USE_GL_FUNC(glBeginFragmentShaderATI)
    USE_GL_FUNC(glBindFragmentShaderATI)
    USE_GL_FUNC(glColorFragmentOp1ATI)
    USE_GL_FUNC(glColorFragmentOp2ATI)
    USE_GL_FUNC(glColorFragmentOp3ATI)
    USE_GL_FUNC(glDeleteFragmentShaderATI)
    USE_GL_FUNC(glEndFragmentShaderATI)
    USE_GL_FUNC(glGenFragmentShadersATI)
    USE_GL_FUNC(glPassTexCoordATI)
    USE_GL_FUNC(glSampleMapATI)
    USE_GL_FUNC(glSetFragmentShaderConstantATI)
    /* GL_ATI_separate_stencil */
    USE_GL_FUNC(glStencilOpSeparateATI)
    USE_GL_FUNC(glStencilFuncSeparateATI)
    /* GL_EXT_blend_color */
    USE_GL_FUNC(glBlendColorEXT)
    /* GL_EXT_blend_equation_separate */
    USE_GL_FUNC(glBlendFuncSeparateEXT)
    /* GL_EXT_blend_func_separate */
    USE_GL_FUNC(glBlendEquationSeparateEXT)
    /* GL_EXT_blend_minmax */
    USE_GL_FUNC(glBlendEquationEXT)
    /* GL_EXT_depth_bounds_test */
    USE_GL_FUNC(glDepthBoundsEXT)
    /* GL_EXT_draw_buffers2 */
    USE_GL_FUNC(glColorMaskIndexedEXT)
    USE_GL_FUNC(glDisableIndexedEXT)
    USE_GL_FUNC(glEnableIndexedEXT)
    USE_GL_FUNC(glGetBooleanIndexedvEXT)
    USE_GL_FUNC(glGetIntegerIndexedvEXT)
    USE_GL_FUNC(glIsEnabledIndexedEXT)
    /* GL_EXT_fog_coord */
    USE_GL_FUNC(glFogCoordPointerEXT)
    USE_GL_FUNC(glFogCoorddEXT)
    USE_GL_FUNC(glFogCoorddvEXT)
    USE_GL_FUNC(glFogCoordfEXT)
    USE_GL_FUNC(glFogCoordfvEXT)
    /* GL_EXT_framebuffer_blit */
    USE_GL_FUNC(glBlitFramebufferEXT)
    /* GL_EXT_framebuffer_multisample */
    USE_GL_FUNC(glRenderbufferStorageMultisampleEXT)
    /* GL_EXT_framebuffer_object */
    USE_GL_FUNC(glBindFramebufferEXT)
    USE_GL_FUNC(glBindRenderbufferEXT)
    USE_GL_FUNC(glCheckFramebufferStatusEXT)
    USE_GL_FUNC(glDeleteFramebuffersEXT)
    USE_GL_FUNC(glDeleteRenderbuffersEXT)
    USE_GL_FUNC(glFramebufferRenderbufferEXT)
    USE_GL_FUNC(glFramebufferTexture1DEXT)
    USE_GL_FUNC(glFramebufferTexture2DEXT)
    USE_GL_FUNC(glFramebufferTexture3DEXT)
    USE_GL_FUNC(glGenFramebuffersEXT)
    USE_GL_FUNC(glGenRenderbuffersEXT)
    USE_GL_FUNC(glGenerateMipmapEXT)
    USE_GL_FUNC(glGetFramebufferAttachmentParameterivEXT)
    USE_GL_FUNC(glGetRenderbufferParameterivEXT)
    USE_GL_FUNC(glIsFramebufferEXT)
    USE_GL_FUNC(glIsRenderbufferEXT)
    USE_GL_FUNC(glRenderbufferStorageEXT)
    /* GL_EXT_gpu_program_parameters */
    USE_GL_FUNC(glProgramEnvParameters4fvEXT)
    USE_GL_FUNC(glProgramLocalParameters4fvEXT)
    /* GL_EXT_gpu_shader4 */
    USE_GL_FUNC(glBindFragDataLocationEXT)
    USE_GL_FUNC(glGetFragDataLocationEXT)
    USE_GL_FUNC(glGetUniformuivEXT)
    USE_GL_FUNC(glGetVertexAttribIivEXT)
    USE_GL_FUNC(glGetVertexAttribIuivEXT)
    USE_GL_FUNC(glUniform1uiEXT)
    USE_GL_FUNC(glUniform1uivEXT)
    USE_GL_FUNC(glUniform2uiEXT)
    USE_GL_FUNC(glUniform2uivEXT)
    USE_GL_FUNC(glUniform3uiEXT)
    USE_GL_FUNC(glUniform3uivEXT)
    USE_GL_FUNC(glUniform4uiEXT)
    USE_GL_FUNC(glUniform4uivEXT)
    USE_GL_FUNC(glVertexAttribI1iEXT)
    USE_GL_FUNC(glVertexAttribI1ivEXT)
    USE_GL_FUNC(glVertexAttribI1uiEXT)
    USE_GL_FUNC(glVertexAttribI1uivEXT)
    USE_GL_FUNC(glVertexAttribI2iEXT)
    USE_GL_FUNC(glVertexAttribI2ivEXT)
    USE_GL_FUNC(glVertexAttribI2uiEXT)
    USE_GL_FUNC(glVertexAttribI2uivEXT)
    USE_GL_FUNC(glVertexAttribI3iEXT)
    USE_GL_FUNC(glVertexAttribI3ivEXT)
    USE_GL_FUNC(glVertexAttribI3uiEXT)
    USE_GL_FUNC(glVertexAttribI3uivEXT)
    USE_GL_FUNC(glVertexAttribI4bvEXT)
    USE_GL_FUNC(glVertexAttribI4iEXT)
    USE_GL_FUNC(glVertexAttribI4ivEXT)
    USE_GL_FUNC(glVertexAttribI4svEXT)
    USE_GL_FUNC(glVertexAttribI4ubvEXT)
    USE_GL_FUNC(glVertexAttribI4uiEXT)
    USE_GL_FUNC(glVertexAttribI4uivEXT)
    USE_GL_FUNC(glVertexAttribI4usvEXT)
    USE_GL_FUNC(glVertexAttribIPointerEXT)
    /* GL_EXT_point_parameters */
    USE_GL_FUNC(glPointParameterfEXT)
    USE_GL_FUNC(glPointParameterfvEXT)
    /* GL_EXT_polygon_offset_clamp */
    USE_GL_FUNC(glPolygonOffsetClampEXT)
    /* GL_EXT_provoking_vertex */
    USE_GL_FUNC(glProvokingVertexEXT)
    /* GL_EXT_secondary_color */
    USE_GL_FUNC(glSecondaryColor3fEXT)
    USE_GL_FUNC(glSecondaryColor3fvEXT)
    USE_GL_FUNC(glSecondaryColor3ubEXT)
    USE_GL_FUNC(glSecondaryColor3ubvEXT)
    USE_GL_FUNC(glSecondaryColorPointerEXT)
    /* GL_EXT_stencil_two_side */
    USE_GL_FUNC(glActiveStencilFaceEXT)
    /* GL_EXT_texture3D */
    USE_GL_FUNC(glTexImage3D)
    USE_GL_FUNC(glTexImage3DEXT)
    USE_GL_FUNC(glTexSubImage3D)
    USE_GL_FUNC(glTexSubImage3DEXT)
    /* GL_NV_fence */
    USE_GL_FUNC(glDeleteFencesNV)
    USE_GL_FUNC(glFinishFenceNV)
    USE_GL_FUNC(glGenFencesNV)
    USE_GL_FUNC(glGetFenceivNV)
    USE_GL_FUNC(glIsFenceNV)
    USE_GL_FUNC(glSetFenceNV)
    USE_GL_FUNC(glTestFenceNV)
    /* GL_NV_half_float */
    USE_GL_FUNC(glColor3hNV)
    USE_GL_FUNC(glColor3hvNV)
    USE_GL_FUNC(glColor4hNV)
    USE_GL_FUNC(glColor4hvNV)
    USE_GL_FUNC(glFogCoordhNV)
    USE_GL_FUNC(glFogCoordhvNV)
    USE_GL_FUNC(glMultiTexCoord1hNV)
    USE_GL_FUNC(glMultiTexCoord1hvNV)
    USE_GL_FUNC(glMultiTexCoord2hNV)
    USE_GL_FUNC(glMultiTexCoord2hvNV)
    USE_GL_FUNC(glMultiTexCoord3hNV)
    USE_GL_FUNC(glMultiTexCoord3hvNV)
    USE_GL_FUNC(glMultiTexCoord4hNV)
    USE_GL_FUNC(glMultiTexCoord4hvNV)
    USE_GL_FUNC(glNormal3hNV)
    USE_GL_FUNC(glNormal3hvNV)
    USE_GL_FUNC(glSecondaryColor3hNV)
    USE_GL_FUNC(glSecondaryColor3hvNV)
    USE_GL_FUNC(glTexCoord1hNV)
    USE_GL_FUNC(glTexCoord1hvNV)
    USE_GL_FUNC(glTexCoord2hNV)
    USE_GL_FUNC(glTexCoord2hvNV)
    USE_GL_FUNC(glTexCoord3hNV)
    USE_GL_FUNC(glTexCoord3hvNV)
    USE_GL_FUNC(glTexCoord4hNV)
    USE_GL_FUNC(glTexCoord4hvNV)
    USE_GL_FUNC(glVertex2hNV)
    USE_GL_FUNC(glVertex2hvNV)
    USE_GL_FUNC(glVertex3hNV)
    USE_GL_FUNC(glVertex3hvNV)
    USE_GL_FUNC(glVertex4hNV)
    USE_GL_FUNC(glVertex4hvNV)
    USE_GL_FUNC(glVertexAttrib1hNV)
    USE_GL_FUNC(glVertexAttrib1hvNV)
    USE_GL_FUNC(glVertexAttrib2hNV)
    USE_GL_FUNC(glVertexAttrib2hvNV)
    USE_GL_FUNC(glVertexAttrib3hNV)
    USE_GL_FUNC(glVertexAttrib3hvNV)
    USE_GL_FUNC(glVertexAttrib4hNV)
    USE_GL_FUNC(glVertexAttrib4hvNV)
    USE_GL_FUNC(glVertexAttribs1hvNV)
    USE_GL_FUNC(glVertexAttribs2hvNV)
    USE_GL_FUNC(glVertexAttribs3hvNV)
    USE_GL_FUNC(glVertexAttribs4hvNV)
    USE_GL_FUNC(glVertexWeighthNV)
    USE_GL_FUNC(glVertexWeighthvNV)
    /* GL_NV_point_sprite */
    USE_GL_FUNC(glPointParameteriNV)
    USE_GL_FUNC(glPointParameterivNV)
    /* GL_NV_register_combiners */
    USE_GL_FUNC(glCombinerInputNV)
    USE_GL_FUNC(glCombinerOutputNV)
    USE_GL_FUNC(glCombinerParameterfNV)
    USE_GL_FUNC(glCombinerParameterfvNV)
    USE_GL_FUNC(glCombinerParameteriNV)
    USE_GL_FUNC(glCombinerParameterivNV)
    USE_GL_FUNC(glFinalCombinerInputNV)
    /* WGL extensions */
    USE_GL_FUNC(wglChoosePixelFormatARB)
    USE_GL_FUNC(wglGetExtensionsStringARB)
    USE_GL_FUNC(wglGetPixelFormatAttribfvARB)
    USE_GL_FUNC(wglGetPixelFormatAttribivARB)
    USE_GL_FUNC(wglQueryCurrentRendererIntegerWINE)
    USE_GL_FUNC(wglQueryCurrentRendererStringWINE)
    USE_GL_FUNC(wglQueryRendererIntegerWINE)
    USE_GL_FUNC(wglQueryRendererStringWINE)
    USE_GL_FUNC(wglSetPixelFormatWINE)
    USE_GL_FUNC(wglSwapIntervalEXT)

    /* Newer core functions */
    USE_GL_FUNC(glActiveTexture)                               /* OpenGL 1.3 */
    USE_GL_FUNC(glAttachShader)                                /* OpenGL 2.0 */
    USE_GL_FUNC(glBeginQuery)                                  /* OpenGL 1.5 */
    USE_GL_FUNC(glBeginTransformFeedback)                      /* OpenGL 3.0 */
    USE_GL_FUNC(glBindAttribLocation)                          /* OpenGL 2.0 */
    USE_GL_FUNC(glBindBuffer)                                  /* OpenGL 1.5 */
    USE_GL_FUNC(glBindFragDataLocation)                        /* OpenGL 3.0 */
    USE_GL_FUNC(glBindVertexArray)                             /* OpenGL 3.0 */
    USE_GL_FUNC(glBlendColor)                                  /* OpenGL 1.4 */
    USE_GL_FUNC(glBlendEquation)                               /* OpenGL 1.4 */
    USE_GL_FUNC(glBlendEquationSeparate)                       /* OpenGL 2.0 */
    USE_GL_FUNC(glBlendFuncSeparate)                           /* OpenGL 1.4 */
    USE_GL_FUNC(glBufferData)                                  /* OpenGL 1.5 */
    USE_GL_FUNC(glBufferSubData)                               /* OpenGL 1.5 */
    USE_GL_FUNC(glColorMaski)                                  /* OpenGL 3.0 */
    USE_GL_FUNC(glCompileShader)                               /* OpenGL 2.0 */
    USE_GL_FUNC(glCompressedTexImage2D)                        /* OpenGL 1.3 */
    USE_GL_FUNC(glCompressedTexImage3D)                        /* OpenGL 1.3 */
    USE_GL_FUNC(glCompressedTexSubImage2D)                     /* OpenGL 1.3 */
    USE_GL_FUNC(glCompressedTexSubImage3D)                     /* OpenGL 1.3 */
    USE_GL_FUNC(glCreateProgram)                               /* OpenGL 2.0 */
    USE_GL_FUNC(glCreateShader)                                /* OpenGL 2.0 */
    USE_GL_FUNC(glDebugMessageCallback)                        /* OpenGL 4.3 */
    USE_GL_FUNC(glDebugMessageControl)                         /* OpenGL 4.3 */
    USE_GL_FUNC(glDebugMessageInsert)                          /* OpenGL 4.3 */
    USE_GL_FUNC(glDeleteBuffers)                               /* OpenGL 1.5 */
    USE_GL_FUNC(glDeleteProgram)                               /* OpenGL 2.0 */
    USE_GL_FUNC(glDeleteQueries)                               /* OpenGL 1.5 */
    USE_GL_FUNC(glDeleteShader)                                /* OpenGL 2.0 */
    USE_GL_FUNC(glDeleteVertexArrays)                          /* OpenGL 3.0 */
    USE_GL_FUNC(glDetachShader)                                /* OpenGL 2.0 */
    USE_GL_FUNC(glDisablei)                                    /* OpenGL 3.0 */
    USE_GL_FUNC(glDisableVertexAttribArray)                    /* OpenGL 2.0 */
    USE_GL_FUNC(glDrawArraysInstanced)                         /* OpenGL 3.1 */
    USE_GL_FUNC(glDrawBuffers)                                 /* OpenGL 2.0 */
    USE_GL_FUNC(glDrawElementsInstanced)                       /* OpenGL 3.1 */
    USE_GL_FUNC(glEnablei)                                     /* OpenGL 3.0 */
    USE_GL_FUNC(glEnableVertexAttribArray)                     /* OpenGL 2.0 */
    USE_GL_FUNC(glEndQuery)                                    /* OpenGL 1.5 */
    USE_GL_FUNC(glEndTransformFeedback)                        /* OpenGL 3.0 */
    USE_GL_FUNC(glFramebufferTexture)                          /* OpenGL 3.2 */
    USE_GL_FUNC(glGenBuffers)                                  /* OpenGL 1.5 */
    USE_GL_FUNC(glGenQueries)                                  /* OpenGL 1.5 */
    USE_GL_FUNC(glGenVertexArrays)                             /* OpenGL 3.0 */
    USE_GL_FUNC(glGetActiveUniform)                            /* OpenGL 2.0 */
    USE_GL_FUNC(glGetAttachedShaders)                          /* OpenGL 2.0 */
    USE_GL_FUNC(glGetAttribLocation)                           /* OpenGL 2.0 */
    USE_GL_FUNC(glGetBooleani_v)                               /* OpenGL 3.0 */
    USE_GL_FUNC(glGetBufferSubData)                            /* OpenGL 1.5 */
    USE_GL_FUNC(glGetCompressedTexImage)                       /* OpenGL 1.3 */
    USE_GL_FUNC(glGetDebugMessageLog)                          /* OpenGL 4.3 */
    USE_GL_FUNC(glGetIntegeri_v)                               /* OpenGL 3.0 */
    USE_GL_FUNC(glGetProgramInfoLog)                           /* OpenGL 2.0 */
    USE_GL_FUNC(glGetProgramiv)                                /* OpenGL 2.0 */
    USE_GL_FUNC(glGetQueryiv)                                  /* OpenGL 1.5 */
    USE_GL_FUNC(glGetQueryObjectuiv)                           /* OpenGL 1.5 */
    USE_GL_FUNC(glGetShaderInfoLog)                            /* OpenGL 2.0 */
    USE_GL_FUNC(glGetShaderiv)                                 /* OpenGL 2.0 */
    USE_GL_FUNC(glGetShaderSource)                             /* OpenGL 2.0 */
    USE_GL_FUNC(glGetStringi)                                  /* OpenGL 3.0 */
    USE_GL_FUNC(glGetTextureLevelParameteriv)                  /* OpenGL 4.5 */
    USE_GL_FUNC(glGetTextureParameteriv)                       /* OpenGL 4.5 */
    USE_GL_FUNC(glGetUniformfv)                                /* OpenGL 2.0 */
    USE_GL_FUNC(glGetUniformiv)                                /* OpenGL 2.0 */
    USE_GL_FUNC(glGetUniformLocation)                          /* OpenGL 2.0 */
    USE_GL_FUNC(glIsEnabledi)                                  /* OpenGL 3.0 */
    USE_GL_FUNC(glLinkProgram)                                 /* OpenGL 2.0 */
    USE_GL_FUNC(glMapBuffer)                                   /* OpenGL 1.5 */
    USE_GL_FUNC(glPointParameteri)                             /* OpenGL 1.4 */
    USE_GL_FUNC(glPointParameteriv)                            /* OpenGL 1.4 */
    USE_GL_FUNC(glShaderSource)                                /* OpenGL 2.0 */
    USE_GL_FUNC(glStencilFuncSeparate)                         /* OpenGL 2.0 */
    USE_GL_FUNC(glStencilOpSeparate)                           /* OpenGL 2.0 */
    USE_GL_FUNC(glTexBuffer)                                   /* OpenGL 3.1 */
    USE_GL_FUNC(glTexImage3D)                                  /* OpenGL 1.2 */
    USE_GL_FUNC(glTexSubImage3D)                               /* OpenGL 1.2 */
    USE_GL_FUNC(glTransformFeedbackVaryings)                   /* OpenGL 3.0 */
    USE_GL_FUNC(glUniform1f)                                   /* OpenGL 2.0 */
    USE_GL_FUNC(glUniform1fv)                                  /* OpenGL 2.0 */
    USE_GL_FUNC(glUniform1i)                                   /* OpenGL 2.0 */
    USE_GL_FUNC(glUniform1iv)                                  /* OpenGL 2.0 */
    USE_GL_FUNC(glUniform2f)                                   /* OpenGL 2.0 */
    USE_GL_FUNC(glUniform2fv)                                  /* OpenGL 2.0 */
    USE_GL_FUNC(glUniform2i)                                   /* OpenGL 2.0 */
    USE_GL_FUNC(glUniform2iv)                                  /* OpenGL 2.0 */
    USE_GL_FUNC(glUniform3f)                                   /* OpenGL 2.0 */
    USE_GL_FUNC(glUniform3fv)                                  /* OpenGL 2.0 */
    USE_GL_FUNC(glUniform3i)                                   /* OpenGL 2.0 */
    USE_GL_FUNC(glUniform3iv)                                  /* OpenGL 2.0 */
    USE_GL_FUNC(glUniform4f)                                   /* OpenGL 2.0 */
    USE_GL_FUNC(glUniform4fv)                                  /* OpenGL 2.0 */
    USE_GL_FUNC(glUniform4i)                                   /* OpenGL 2.0 */
    USE_GL_FUNC(glUniform4iv)                                  /* OpenGL 2.0 */
    USE_GL_FUNC(glUniformMatrix2fv)                            /* OpenGL 2.0 */
    USE_GL_FUNC(glUniformMatrix3fv)                            /* OpenGL 2.0 */
    USE_GL_FUNC(glUniformMatrix4fv)                            /* OpenGL 2.0 */
    USE_GL_FUNC(glUnmapBuffer)                                 /* OpenGL 1.5 */
    USE_GL_FUNC(glUseProgram)                                  /* OpenGL 2.0 */
    USE_GL_FUNC(glValidateProgram)                             /* OpenGL 2.0 */
    USE_GL_FUNC(glVertexAttrib1f)                              /* OpenGL 2.0 */
    USE_GL_FUNC(glVertexAttrib1fv)                             /* OpenGL 2.0 */
    USE_GL_FUNC(glVertexAttrib2f)                              /* OpenGL 2.0 */
    USE_GL_FUNC(glVertexAttrib2fv)                             /* OpenGL 2.0 */
    USE_GL_FUNC(glVertexAttrib3f)                              /* OpenGL 2.0 */
    USE_GL_FUNC(glVertexAttrib3fv)                             /* OpenGL 2.0 */
    USE_GL_FUNC(glVertexAttrib4f)                              /* OpenGL 2.0 */
    USE_GL_FUNC(glVertexAttrib4fv)                             /* OpenGL 2.0 */
    USE_GL_FUNC(glVertexAttrib4Nsv)                            /* OpenGL 2.0 */
    USE_GL_FUNC(glVertexAttrib4Nub)                            /* OpenGL 2.0 */
    USE_GL_FUNC(glVertexAttrib4Nubv)                           /* OpenGL 2.0 */
    USE_GL_FUNC(glVertexAttrib4Nusv)                           /* OpenGL 2.0 */
    USE_GL_FUNC(glVertexAttrib4sv)                             /* OpenGL 2.0 */
    USE_GL_FUNC(glVertexAttrib4ubv)                            /* OpenGL 2.0 */
    USE_GL_FUNC(glVertexAttribDivisor)                         /* OpenGL 3.3 */
    USE_GL_FUNC(glVertexAttribIPointer)                        /* OpenGL 3.0 */
    USE_GL_FUNC(glVertexAttribPointer)                         /* OpenGL 2.0 */
#undef USE_GL_FUNC

#ifndef USE_WIN32_OPENGL
    /* hack: use the functions directly from the TEB table to bypass the thunks */
    /* note that we still need the above wglGetProcAddress calls to initialize the table */
    gl_info->gl_ops.ext = ((struct opengl_funcs *)NtCurrentTeb()->glTable)->ext;
#endif

#define MAP_GL_FUNCTION(core_func, ext_func)                                          \
        do                                                                            \
        {                                                                             \
            if (!gl_info->gl_ops.ext.p_##core_func)                                   \
                gl_info->gl_ops.ext.p_##core_func = gl_info->gl_ops.ext.p_##ext_func; \
        } while (0)
#define MAP_GL_FUNCTION_CAST(core_func, ext_func)                                             \
        do                                                                                    \
        {                                                                                     \
            if (!gl_info->gl_ops.ext.p_##core_func)                                           \
                gl_info->gl_ops.ext.p_##core_func = (void *)gl_info->gl_ops.ext.p_##ext_func; \
        } while (0)

    MAP_GL_FUNCTION(glActiveTexture, glActiveTextureARB);
    MAP_GL_FUNCTION(glAttachShader, glAttachObjectARB);
    MAP_GL_FUNCTION(glBeginQuery, glBeginQueryARB);
    MAP_GL_FUNCTION(glBindAttribLocation, glBindAttribLocationARB);
    MAP_GL_FUNCTION(glBindBuffer, glBindBufferARB);
    MAP_GL_FUNCTION(glBindFragDataLocation, glBindFragDataLocationEXT);
    MAP_GL_FUNCTION(glBlendColor, glBlendColorEXT);
    MAP_GL_FUNCTION(glBlendEquation, glBlendEquationEXT);
    MAP_GL_FUNCTION(glBlendEquationSeparate, glBlendEquationSeparateEXT);
    MAP_GL_FUNCTION(glBlendFuncSeparate, glBlendFuncSeparateEXT);
    MAP_GL_FUNCTION(glBufferData, glBufferDataARB);
    MAP_GL_FUNCTION(glBufferSubData, glBufferSubDataARB);
    MAP_GL_FUNCTION(glColorMaski, glColorMaskIndexedEXT);
    MAP_GL_FUNCTION(glCompileShader, glCompileShaderARB);
    MAP_GL_FUNCTION(glCompressedTexImage2D, glCompressedTexImage2DARB);
    MAP_GL_FUNCTION(glCompressedTexImage3D, glCompressedTexImage3DARB);
    MAP_GL_FUNCTION(glCompressedTexSubImage2D, glCompressedTexSubImage2DARB);
    MAP_GL_FUNCTION(glCompressedTexSubImage3D, glCompressedTexSubImage3DARB);
    MAP_GL_FUNCTION(glCreateProgram, glCreateProgramObjectARB);
    MAP_GL_FUNCTION(glCreateShader, glCreateShaderObjectARB);
    MAP_GL_FUNCTION(glDebugMessageCallback, glDebugMessageCallbackARB);
    MAP_GL_FUNCTION(glDebugMessageControl, glDebugMessageControlARB);
    MAP_GL_FUNCTION(glDebugMessageInsert, glDebugMessageInsertARB);
    MAP_GL_FUNCTION(glDeleteBuffers, glDeleteBuffersARB);
    MAP_GL_FUNCTION(glDeleteProgram, glDeleteObjectARB);
    MAP_GL_FUNCTION(glDeleteQueries, glDeleteQueriesARB);
    MAP_GL_FUNCTION(glDeleteShader, glDeleteObjectARB);
    MAP_GL_FUNCTION(glDetachShader, glDetachObjectARB);
    MAP_GL_FUNCTION(glDisablei, glDisableIndexedEXT);
    MAP_GL_FUNCTION(glDisableVertexAttribArray, glDisableVertexAttribArrayARB);
    MAP_GL_FUNCTION(glDrawArraysInstanced, glDrawArraysInstancedARB);
    MAP_GL_FUNCTION(glDrawBuffers, glDrawBuffersARB);
    MAP_GL_FUNCTION(glDrawElementsInstanced, glDrawElementsInstancedARB);
    MAP_GL_FUNCTION(glEnablei, glEnableIndexedEXT);
    MAP_GL_FUNCTION(glEnableVertexAttribArray, glEnableVertexAttribArrayARB);
    MAP_GL_FUNCTION(glEndQuery, glEndQueryARB);
    MAP_GL_FUNCTION(glFramebufferTexture, glFramebufferTextureARB);
    MAP_GL_FUNCTION(glGenBuffers, glGenBuffersARB);
    MAP_GL_FUNCTION(glGenQueries, glGenQueriesARB);
    MAP_GL_FUNCTION(glGetActiveUniform, glGetActiveUniformARB);
    MAP_GL_FUNCTION(glGetAttachedShaders, glGetAttachedObjectsARB);
    MAP_GL_FUNCTION(glGetAttribLocation, glGetAttribLocationARB);
    MAP_GL_FUNCTION(glGetBooleani_v, glGetBooleanIndexedvEXT);
    MAP_GL_FUNCTION(glGetBufferSubData, glGetBufferSubDataARB);
    MAP_GL_FUNCTION(glGetCompressedTexImage, glGetCompressedTexImageARB);
    MAP_GL_FUNCTION(glGetDebugMessageLog, glGetDebugMessageLogARB);
    MAP_GL_FUNCTION(glGetIntegeri_v, glGetIntegerIndexedvEXT);
    MAP_GL_FUNCTION(glGetProgramInfoLog, glGetInfoLogARB);
    MAP_GL_FUNCTION(glGetProgramiv, glGetObjectParameterivARB);
    MAP_GL_FUNCTION(glGetQueryiv, glGetQueryivARB);
    MAP_GL_FUNCTION(glGetQueryObjectuiv, glGetQueryObjectuivARB);
    MAP_GL_FUNCTION(glGetShaderInfoLog, glGetInfoLogARB);
    MAP_GL_FUNCTION(glGetShaderiv, glGetObjectParameterivARB);
    MAP_GL_FUNCTION(glGetShaderSource, glGetShaderSourceARB);
    MAP_GL_FUNCTION(glGetUniformfv, glGetUniformfvARB);
    MAP_GL_FUNCTION(glGetUniformiv, glGetUniformivARB);
    MAP_GL_FUNCTION(glGetUniformLocation, glGetUniformLocationARB);
    MAP_GL_FUNCTION(glIsEnabledi, glIsEnabledIndexedEXT);
    MAP_GL_FUNCTION(glLinkProgram, glLinkProgramARB);
    MAP_GL_FUNCTION(glMapBuffer, glMapBufferARB);
    MAP_GL_FUNCTION_CAST(glShaderSource, glShaderSourceARB);
    MAP_GL_FUNCTION(glTexBuffer, glTexBufferARB);
    MAP_GL_FUNCTION_CAST(glTexImage3D, glTexImage3DEXT);
    MAP_GL_FUNCTION(glTexSubImage3D, glTexSubImage3DEXT);
    MAP_GL_FUNCTION(glUniform1f, glUniform1fARB);
    MAP_GL_FUNCTION(glUniform1fv, glUniform1fvARB);
    MAP_GL_FUNCTION(glUniform1i, glUniform1iARB);
    MAP_GL_FUNCTION(glUniform1iv, glUniform1ivARB);
    MAP_GL_FUNCTION(glUniform2f, glUniform2fARB);
    MAP_GL_FUNCTION(glUniform2fv, glUniform2fvARB);
    MAP_GL_FUNCTION(glUniform2i, glUniform2iARB);
    MAP_GL_FUNCTION(glUniform2iv, glUniform2ivARB);
    MAP_GL_FUNCTION(glUniform3f, glUniform3fARB);
    MAP_GL_FUNCTION(glUniform3fv, glUniform3fvARB);
    MAP_GL_FUNCTION(glUniform3i, glUniform3iARB);
    MAP_GL_FUNCTION(glUniform3iv, glUniform3ivARB);
    MAP_GL_FUNCTION(glUniform4f, glUniform4fARB);
    MAP_GL_FUNCTION(glUniform4fv, glUniform4fvARB);
    MAP_GL_FUNCTION(glUniform4i, glUniform4iARB);
    MAP_GL_FUNCTION(glUniform4iv, glUniform4ivARB);
    MAP_GL_FUNCTION(glUniformMatrix2fv, glUniformMatrix2fvARB);
    MAP_GL_FUNCTION(glUniformMatrix3fv, glUniformMatrix3fvARB);
    MAP_GL_FUNCTION(glUniformMatrix4fv, glUniformMatrix4fvARB);
    MAP_GL_FUNCTION(glUnmapBuffer, glUnmapBufferARB);
    MAP_GL_FUNCTION(glUseProgram, glUseProgramObjectARB);
    MAP_GL_FUNCTION(glValidateProgram, glValidateProgramARB);
    MAP_GL_FUNCTION(glVertexAttrib1f, glVertexAttrib1fARB);
    MAP_GL_FUNCTION(glVertexAttrib1fv, glVertexAttrib1fvARB);
    MAP_GL_FUNCTION(glVertexAttrib2f, glVertexAttrib2fARB);
    MAP_GL_FUNCTION(glVertexAttrib2fv, glVertexAttrib2fvARB);
    MAP_GL_FUNCTION(glVertexAttrib3f, glVertexAttrib3fARB);
    MAP_GL_FUNCTION(glVertexAttrib3fv, glVertexAttrib3fvARB);
    MAP_GL_FUNCTION(glVertexAttrib4f, glVertexAttrib4fARB);
    MAP_GL_FUNCTION(glVertexAttrib4fv, glVertexAttrib4fvARB);
    MAP_GL_FUNCTION(glVertexAttrib4Nsv, glVertexAttrib4NsvARB);
    MAP_GL_FUNCTION(glVertexAttrib4Nub, glVertexAttrib4NubARB);
    MAP_GL_FUNCTION(glVertexAttrib4Nubv, glVertexAttrib4NubvARB);
    MAP_GL_FUNCTION(glVertexAttrib4Nusv, glVertexAttrib4NusvARB);
    MAP_GL_FUNCTION(glVertexAttrib4sv, glVertexAttrib4svARB);
    MAP_GL_FUNCTION(glVertexAttrib4ubv, glVertexAttrib4ubvARB);
    MAP_GL_FUNCTION(glVertexAttribDivisor, glVertexAttribDivisorARB);
    MAP_GL_FUNCTION(glVertexAttribIPointer, glVertexAttribIPointerEXT);
    MAP_GL_FUNCTION(glVertexAttribPointer, glVertexAttribPointerARB);
#undef MAP_GL_FUNCTION
#undef MAP_GL_FUNCTION_CAST
}

Referenced by wined3d_adapter_init_gl_caps().

match_allows_spec_alpha()

static BOOL match_allows_spec_alpha ( const struct wined3d_gl_info *  gl_info, struct wined3d_caps_gl_ctx *  ctx, const char *  gl_renderer, enum wined3d_gl_vendor  gl_vendor, enum wined3d_pci_vendor  card_vendor, enum wined3d_pci_device  device  )

static

Definition at line 674 of file directx.c.

{
    GLenum error;
    DWORD data[16];

    if (!gl_info->supported[EXT_SECONDARY_COLOR])
        return FALSE;

    while (gl_info->gl_ops.gl.p_glGetError());
    GL_EXTCALL(glSecondaryColorPointerEXT)(4, GL_UNSIGNED_BYTE, 4, data);
    error = gl_info->gl_ops.gl.p_glGetError();

    if (error == GL_NO_ERROR)
    {
        TRACE("GL Implementation accepts 4 component specular color pointers\n");
        return TRUE;
    }
    else
    {
        TRACE("GL implementation does not accept 4 component specular colors, error %s\n",
              debug_glerror(error));
        return FALSE;
    }
}

match_amd_r300_to_500()

static BOOL match_amd_r300_to_500 ( const struct wined3d_gl_info *  gl_info, struct wined3d_caps_gl_ctx *  ctx, const char *  gl_renderer, enum wined3d_gl_vendor  gl_vendor, enum wined3d_pci_vendor  card_vendor, enum wined3d_pci_device  device  )

static

Definition at line 521 of file directx.c.

{
    if (card_vendor != HW_VENDOR_AMD) return FALSE;
    if (device == CARD_AMD_RADEON_9500) return TRUE;
    if (device == CARD_AMD_RADEON_X700) return TRUE;
    if (device == CARD_AMD_RADEON_X1600) return TRUE;
    return FALSE;
}

match_apple()

static BOOL match_apple ( const struct wined3d_gl_info *  gl_info, struct wined3d_caps_gl_ctx *  ctx, const char *  gl_renderer, enum wined3d_gl_vendor  gl_vendor, enum wined3d_pci_vendor  card_vendor, enum wined3d_pci_device  device  )

static

Definition at line 548 of file directx.c.

{
    /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
     * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
     * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
     *
     * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
     * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
     * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
     * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
     * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
     * the chance that other implementations support them is rather small since Win32 QuickTime uses
     * DirectDraw, not OpenGL.
     *
     * This test has been moved into wined3d_guess_gl_vendor()
     */
    return gl_vendor == GL_VENDOR_APPLE;
}

match_apple_intel()

static BOOL match_apple_intel ( const struct wined3d_gl_info *  gl_info, struct wined3d_caps_gl_ctx *  ctx, const char *  gl_renderer, enum wined3d_gl_vendor  gl_vendor, enum wined3d_pci_vendor  card_vendor, enum wined3d_pci_device  device  )

static

Definition at line 635 of file directx.c.

{
    return (card_vendor == HW_VENDOR_INTEL) && (gl_vendor == GL_VENDOR_APPLE);
}

match_apple_nonr500ati()

static BOOL match_apple_nonr500ati ( const struct wined3d_gl_info *  gl_info, struct wined3d_caps_gl_ctx *  ctx, const char *  gl_renderer, enum wined3d_gl_vendor  gl_vendor, enum wined3d_pci_vendor  card_vendor, enum wined3d_pci_device  device  )

static

Definition at line 642 of file directx.c.

{
    if (gl_vendor != GL_VENDOR_APPLE) return FALSE;
    if (card_vendor != HW_VENDOR_AMD) return FALSE;
    if (device == CARD_AMD_RADEON_X1600) return FALSE;
    return TRUE;
}

match_broken_arb_fog()

static BOOL match_broken_arb_fog ( const struct wined3d_gl_info *  gl_info, struct wined3d_caps_gl_ctx *  ctx, const char *  gl_renderer, enum wined3d_gl_vendor  gl_vendor, enum wined3d_pci_vendor  card_vendor, enum wined3d_pci_device  device  )

static

Definition at line 841 of file directx.c.

{
    DWORD data[4];
    GLuint tex, fbo;
    GLenum status;
    float color[4] = {0.0f, 1.0f, 0.0f, 0.0f};
    GLuint prog;
    GLint err_pos;
    static const char program_code[] =
        "!!ARBfp1.0\n"
        "OPTION ARB_fog_linear;\n"
        "MOV result.color, {1.0, 0.0, 0.0, 0.0};\n"
        "END\n";

    if (wined3d_settings.offscreen_rendering_mode != ORM_FBO)
        return FALSE;
    if (!gl_info->supported[ARB_FRAGMENT_PROGRAM])
        return FALSE;

    gl_info->gl_ops.gl.p_glGenTextures(1, &tex);
    gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex);
    gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, 4, 1, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
    checkGLcall("glTexImage2D");

    gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
    gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
    gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
    checkGLcall("glFramebufferTexture2D");

    status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
    if (status != GL_FRAMEBUFFER_COMPLETE) ERR("FBO status %#x\n", status);
    checkGLcall("glCheckFramebufferStatus");

    gl_info->gl_ops.gl.p_glClearColor(0.0f, 0.0f, 1.0f, 0.0f);
    gl_info->gl_ops.gl.p_glClear(GL_COLOR_BUFFER_BIT);
    checkGLcall("glClear");
    gl_info->gl_ops.gl.p_glViewport(0, 0, 4, 1);
    checkGLcall("glViewport");

    gl_info->gl_ops.gl.p_glEnable(GL_FOG);
    gl_info->gl_ops.gl.p_glFogf(GL_FOG_START, 0.5f);
    gl_info->gl_ops.gl.p_glFogf(GL_FOG_END, 0.5f);
    gl_info->gl_ops.gl.p_glFogi(GL_FOG_MODE, GL_LINEAR);
    gl_info->gl_ops.gl.p_glHint(GL_FOG_HINT, GL_NICEST);
    gl_info->gl_ops.gl.p_glFogfv(GL_FOG_COLOR, color);
    checkGLcall("fog setup");

    GL_EXTCALL(glGenProgramsARB(1, &prog));
    GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prog));
    GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
            strlen(program_code), program_code));
    gl_info->gl_ops.gl.p_glEnable(GL_FRAGMENT_PROGRAM_ARB);
    checkGLcall("Test fragment program setup");

    gl_info->gl_ops.gl.p_glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &err_pos);
    if (err_pos != -1)
    {
        const char *error_str;
        error_str = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_PROGRAM_ERROR_STRING_ARB);
        FIXME("Fog test program error at position %d: %s\n\n", err_pos, debugstr_a(error_str));
    }

    gl_info->gl_ops.gl.p_glBegin(GL_TRIANGLE_STRIP);
    gl_info->gl_ops.gl.p_glVertex3f(-1.0f, -1.0f,  0.0f);
    gl_info->gl_ops.gl.p_glVertex3f( 1.0f, -1.0f,  1.0f);
    gl_info->gl_ops.gl.p_glVertex3f(-1.0f,  1.0f,  0.0f);
    gl_info->gl_ops.gl.p_glVertex3f( 1.0f,  1.0f,  1.0f);
    gl_info->gl_ops.gl.p_glEnd();
    checkGLcall("ARBfp fog test draw");

    gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
    checkGLcall("glGetTexImage");
    data[0] &= 0x00ffffff;
    data[1] &= 0x00ffffff;
    data[2] &= 0x00ffffff;
    data[3] &= 0x00ffffff;

    gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
    gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, 0);

    gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
    gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex);
    gl_info->gl_ops.gl.p_glDisable(GL_FOG);
    GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0));
    gl_info->gl_ops.gl.p_glDisable(GL_FRAGMENT_PROGRAM_ARB);
    GL_EXTCALL(glDeleteProgramsARB(1, &prog));
    checkGLcall("ARBfp fog test teardown");

    TRACE("Fog test data: %08x %08x %08x %08x\n", data[0], data[1], data[2], data[3]);
    return data[0] != 0x00ff0000 || data[3] != 0x0000ff00;
}

match_broken_nv_clip()

static BOOL match_broken_nv_clip ( const struct wined3d_gl_info *  gl_info, struct wined3d_caps_gl_ctx *  ctx, const char *  gl_renderer, enum wined3d_gl_vendor  gl_vendor, enum wined3d_pci_vendor  card_vendor, enum wined3d_pci_device  device  )

static

Definition at line 702 of file directx.c.

{
    GLuint prog;
    BOOL ret = FALSE;
    GLint pos;
    static const char testcode[] =
        "!!ARBvp1.0\n"
        "OPTION NV_vertex_program2;\n"
        "MOV result.clip[0], 0.0;\n"
        "MOV result.position, 0.0;\n"
        "END\n";

    if (!gl_info->supported[NV_VERTEX_PROGRAM2_OPTION]) return FALSE;

    while (gl_info->gl_ops.gl.p_glGetError());

    GL_EXTCALL(glGenProgramsARB(1, &prog));
    if(!prog)
    {
        ERR("Failed to create the NVvp clip test program\n");
        return FALSE;
    }
    GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
    GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
                                  strlen(testcode), testcode));
    gl_info->gl_ops.gl.p_glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
    if(pos != -1)
    {
        WARN("GL_NV_vertex_program2_option result.clip[] test failed\n");
        TRACE("error: %s\n", debugstr_a((const char *)gl_info->gl_ops.gl.p_glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
        ret = TRUE;
        while (gl_info->gl_ops.gl.p_glGetError());
    }
    else TRACE("GL_NV_vertex_program2_option result.clip[] test passed\n");

    GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
    GL_EXTCALL(glDeleteProgramsARB(1, &prog));
    checkGLcall("GL_NV_vertex_program2_option result.clip[] test cleanup");

    return ret;
}

match_broken_rgba16()

static BOOL match_broken_rgba16 ( const struct wined3d_gl_info *  gl_info, struct wined3d_caps_gl_ctx *  ctx, const char *  gl_renderer, enum wined3d_gl_vendor  gl_vendor, enum wined3d_pci_vendor  card_vendor, enum wined3d_pci_device  device  )

static

Definition at line 799 of file directx.c.

{
    /* GL_RGBA16 uses GL_RGBA8 internally on Geforce 7 and older cards.
     * This leads to graphical bugs in Half Life 2 and Unreal engine games. */
    GLuint tex;
    GLint size;

    gl_info->gl_ops.gl.p_glGenTextures(1, &tex);
    gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex);
    gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16, 4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT, NULL);
    checkGLcall("glTexImage2D");

    gl_info->gl_ops.gl.p_glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_RED_SIZE, &size);
    checkGLcall("glGetTexLevelParameteriv");
    TRACE("Real color depth is %d\n", size);

    gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, 0);
    checkGLcall("glBindTexture");
    gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex);
    checkGLcall("glDeleteTextures");

    return size < 16;
}

match_broken_viewport_subpixel_bits()

static BOOL match_broken_viewport_subpixel_bits ( const struct wined3d_gl_info *  gl_info, struct wined3d_caps_gl_ctx *  ctx, const char *  gl_renderer, enum wined3d_gl_vendor  gl_vendor, enum wined3d_pci_vendor  card_vendor, enum wined3d_pci_device  device  )

static

Definition at line 937 of file directx.c.

{
    if (!gl_info->supported[ARB_VIEWPORT_ARRAY])
        return FALSE;
    if (wined3d_settings.offscreen_rendering_mode != ORM_FBO)
        return FALSE;
    return !wined3d_caps_gl_ctx_test_viewport_subpixel_bits(ctx);
}

match_dx10_capable()

static BOOL match_dx10_capable ( const struct wined3d_gl_info *  gl_info, struct wined3d_caps_gl_ctx *  ctx, const char *  gl_renderer, enum wined3d_gl_vendor  gl_vendor, enum wined3d_pci_vendor  card_vendor, enum wined3d_pci_device  device  )

static

Definition at line 652 of file directx.c.

{
    /* DX9 cards support 40 single float varyings in hardware, most drivers report 32. ATI misreports
     * 44 varyings. So assume that if we have more than 44 varyings we have a dx10 card.
     * This detection is for the gl_ClipPos varying quirk. If a d3d9 card really supports more than 44
     * varyings and we subtract one in dx9 shaders it's not going to hurt us because the dx9 limit is
     * hardcoded
     *
     * dx10 cards usually have 64 varyings */
    return gl_info->limits.glsl_varyings > 44;
}

Referenced by match_not_dx10_capable().

match_fbo_tex_update()

static BOOL match_fbo_tex_update ( const struct wined3d_gl_info *  gl_info, struct wined3d_caps_gl_ctx *  ctx, const char *  gl_renderer, enum wined3d_gl_vendor  gl_vendor, enum wined3d_pci_vendor  card_vendor, enum wined3d_pci_device  device  )

static

Definition at line 747 of file directx.c.

{
    char data[4 * 4 * 4];
    GLuint tex, fbo;
    GLenum status;

    if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) return FALSE;

    memset(data, 0xcc, sizeof(data));

    gl_info->gl_ops.gl.p_glGenTextures(1, &tex);
    gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex);
    gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
    checkGLcall("glTexImage2D");

    gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
    gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
    gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
    checkGLcall("glFramebufferTexture2D");

    status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
    if (status != GL_FRAMEBUFFER_COMPLETE) ERR("FBO status %#x\n", status);
    checkGLcall("glCheckFramebufferStatus");

    memset(data, 0x11, sizeof(data));
    gl_info->gl_ops.gl.p_glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
    checkGLcall("glTexSubImage2D");

    gl_info->gl_ops.gl.p_glClearColor(0.996f, 0.729f, 0.745f, 0.792f);
    gl_info->gl_ops.gl.p_glClear(GL_COLOR_BUFFER_BIT);
    checkGLcall("glClear");

    gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
    checkGLcall("glGetTexImage");

    gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
    gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
    gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, 0);
    checkGLcall("glBindTexture");

    gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
    gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex);
    checkGLcall("glDeleteTextures");

    return *(DWORD *)data == 0x11111111;
}

match_fglrx()

static BOOL match_fglrx ( const struct wined3d_gl_info *  gl_info, struct wined3d_caps_gl_ctx *  ctx, const char *  gl_renderer, enum wined3d_gl_vendor  gl_vendor, enum wined3d_pci_vendor  card_vendor, enum wined3d_pci_device  device  )

static

Definition at line 825 of file directx.c.

{
    return gl_vendor == GL_VENDOR_FGLRX;
}

match_geforce5()

static BOOL match_geforce5 ( const struct wined3d_gl_info *  gl_info, struct wined3d_caps_gl_ctx *  ctx, const char *  gl_renderer, enum wined3d_gl_vendor  gl_vendor, enum wined3d_pci_vendor  card_vendor, enum wined3d_pci_device  device  )

static

Definition at line 532 of file directx.c.

{
    if (card_vendor == HW_VENDOR_NVIDIA)
    {
        if (device == CARD_NVIDIA_GEFORCEFX_5200 ||
            device == CARD_NVIDIA_GEFORCEFX_5600 ||
            device == CARD_NVIDIA_GEFORCEFX_5800)
        {
            return TRUE;
        }
    }
    return FALSE;
}

match_not_dx10_capable()

static BOOL match_not_dx10_capable ( const struct wined3d_gl_info *  gl_info, struct wined3d_caps_gl_ctx *  ctx, const char *  gl_renderer, enum wined3d_gl_vendor  gl_vendor, enum wined3d_pci_vendor  card_vendor, enum wined3d_pci_device  device  )

static

Definition at line 666 of file directx.c.

{
    return !match_dx10_capable(gl_info, ctx, gl_renderer, gl_vendor, card_vendor, device);
}

match_r200()

static BOOL match_r200 ( const struct wined3d_gl_info *  gl_info, struct wined3d_caps_gl_ctx *  ctx, const char *  gl_renderer, enum wined3d_gl_vendor  gl_vendor, enum wined3d_pci_vendor  card_vendor, enum wined3d_pci_device  device  )

static

Definition at line 832 of file directx.c.

{
    if (card_vendor != HW_VENDOR_AMD) return FALSE;
    if (device == CARD_AMD_RADEON_8500) return TRUE;
    return FALSE;
}

parse_extension_string()

static void parse_extension_string ( struct wined3d_gl_info *  gl_info, const char *  extensions, const struct wined3d_extension_map *  map, UINT  entry_count  )

static

Definition at line 2638 of file directx.c.

{
    while (*extensions)
    {
        const char *start;
        size_t len;
        UINT i;

        while (isspace(*extensions))
            ++extensions;
        start = extensions;
        while (!isspace(*extensions) && *extensions)
            ++extensions;

        len = extensions - start;
        if (!len)
            continue;

        TRACE("- %s.\n", debugstr_an(start, len));

        for (i = 0; i < entry_count; ++i)
        {
            if (len == strlen(map[i].extension_string)
                    && !memcmp(start, map[i].extension_string, len))
            {
                TRACE(" FOUND: %s support.\n", map[i].extension_string);
                gl_info->supported[map[i].extension] = TRUE;
                break;
            }
        }
    }
}

Referenced by wined3d_adapter_init_gl_caps().

position_d3dcolor()

static void WINE_GLAPI position_d3dcolor ( const void *  data )

static

Definition at line 6300 of file directx.c.

{
    DWORD pos = *((const DWORD *)data);

    FIXME("Add a test for fixed function position from d3dcolor type.\n");
    context_get_current()->gl_info->gl_ops.gl.p_glVertex4s(D3DCOLOR_B_R(pos),
            D3DCOLOR_B_G(pos),
            D3DCOLOR_B_B(pos),
            D3DCOLOR_B_A(pos));
}

Referenced by wined3d_adapter_init_ffp_attrib_ops().

position_float4()

static void WINE_GLAPI position_float4 ( const void *  data )

static

Definition at line 6311 of file directx.c.

{
    const GLfloat *pos = data;

    if (pos[3] != 0.0f && pos[3] != 1.0f)
    {
        float w = 1.0f / pos[3];

        context_get_current()->gl_info->gl_ops.gl.p_glVertex4f(pos[0] * w, pos[1] * w, pos[2] * w, w);
    }
    else
    {
        context_get_current()->gl_info->gl_ops.gl.p_glVertex3fv(pos);
    }
}

Referenced by wined3d_adapter_init_ffp_attrib_ops().

query_gpu_description()

static const struct gpu_description* query_gpu_description ( const struct wined3d_gl_info *  gl_info, UINT64 *  vram_bytes  )

static

Definition at line 1566 of file directx.c.

{
    enum wined3d_pci_vendor vendor = PCI_VENDOR_NONE;
    enum wined3d_pci_device device = PCI_DEVICE_NONE;
    const struct gpu_description *gpu_description;
    static unsigned int once;

    if (gl_info->supported[WGL_WINE_QUERY_RENDERER])
    {
        GLuint value;

        if (GL_EXTCALL(wglQueryCurrentRendererIntegerWINE(WGL_RENDERER_VENDOR_ID_WINE, &value)))
            vendor = value;
        if (GL_EXTCALL(wglQueryCurrentRendererIntegerWINE(WGL_RENDERER_DEVICE_ID_WINE, &value)))
            device = value;
        if (GL_EXTCALL(wglQueryCurrentRendererIntegerWINE(WGL_RENDERER_VIDEO_MEMORY_WINE, &value)))
            *vram_bytes = (UINT64)value * 1024 * 1024;
        TRACE("Card reports vendor PCI ID 0x%04x, device PCI ID 0x%04x, 0x%s bytes of video memory.\n",
                vendor, device, wine_dbgstr_longlong(*vram_bytes));
    }
    else if (gl_info->supported[NVX_GPU_MEMORY_INFO])
    {
        GLint vram_kb;
        gl_info->gl_ops.gl.p_glGetIntegerv(GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX, &vram_kb);

        *vram_bytes = (UINT64)vram_kb * 1024;
        TRACE("Got 0x%s as video memory from NVX_GPU_MEMORY_INFO extension.\n",
                wine_dbgstr_longlong(*vram_bytes));
    }

    if (wined3d_settings.pci_vendor_id != PCI_VENDOR_NONE)
    {
        vendor = wined3d_settings.pci_vendor_id;
        TRACE("Overriding vendor PCI ID with 0x%04x.\n", vendor);
    }

    if (wined3d_settings.pci_device_id != PCI_DEVICE_NONE)
    {
        device = wined3d_settings.pci_device_id;
        TRACE("Overriding device PCI ID with 0x%04x.\n", device);
    }

    if (wined3d_settings.emulated_textureram)
    {
        *vram_bytes = wined3d_settings.emulated_textureram;
        TRACE("Overriding amount of video memory with 0x%s bytes.\n",
                wine_dbgstr_longlong(*vram_bytes));
    }

    if (!(gpu_description = get_gpu_description(vendor, device))
            && (wined3d_settings.pci_vendor_id != PCI_VENDOR_NONE
            || wined3d_settings.pci_device_id != PCI_DEVICE_NONE) && !once++)
        ERR_(winediag)("Invalid GPU override %04x:%04x specified, ignoring.\n", vendor, device);

    return gpu_description;
}

Referenced by wined3d_adapter_init_gl_caps().

quirk_allows_specular_alpha()

static void quirk_allows_specular_alpha ( struct wined3d_gl_info *  gl_info )

static

Definition at line 1023 of file directx.c.

{
    gl_info->quirks |= WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA;
}

quirk_amd_dx9()

static void quirk_amd_dx9 ( struct wined3d_gl_info *  gl_info )

static

Definition at line 957 of file directx.c.

{
    /* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and earlier cards, although
     * these cards only support GL_ARB_texture_rectangle(D3DPTEXTURECAPS_NONPOW2CONDITIONAL).
     * If real NP2 textures are used, the driver falls back to software. We could just remove the
     * extension and use GL_ARB_texture_rectangle instead, but texture_rectangle is inconvenient
     * due to the non-normalized texture coordinates. Thus set an internal extension flag,
     * GL_WINE_normalized_texrect, which signals the code that it can use non power of two textures
     * as per GL_ARB_texture_non_power_of_two, but has to stick to the texture_rectangle limits.
     *
     * fglrx doesn't advertise GL_ARB_texture_non_power_of_two, but it advertises opengl 2.0 which
     * has this extension promoted to core. The extension loading code sets this extension supported
     * due to that, so this code works on fglrx as well. */
    if(gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
    {
        TRACE("GL_ARB_texture_non_power_of_two advertised on R500 or earlier card, removing.\n");
        gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
        gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT] = TRUE;
    }
}

quirk_apple_glsl_constants()

static void quirk_apple_glsl_constants ( struct wined3d_gl_info *  gl_info )

static

Definition at line 948 of file directx.c.

{
    /* MacOS needs uniforms for relative addressing offsets. This can accumulate to quite a few uniforms.
     * Beyond that the general uniform isn't optimal, so reserve a number of uniforms. 12 vec4's should
     * allow 48 different offsets or other helper immediate values. */
    TRACE("Reserving 12 GLSL constants for compiler private use.\n");
    gl_info->reserved_glsl_constants = max(gl_info->reserved_glsl_constants, 12);
}

quirk_broken_arb_fog()

static void quirk_broken_arb_fog ( struct wined3d_gl_info *  gl_info )

static

Definition at line 1071 of file directx.c.

{
    gl_info->quirks |= WINED3D_QUIRK_BROKEN_ARB_FOG;
}

quirk_broken_rgba16()

static void quirk_broken_rgba16 ( struct wined3d_gl_info *  gl_info )

static

Definition at line 1038 of file directx.c.

{
    gl_info->quirks |= WINED3D_QUIRK_BROKEN_RGBA16;
}

quirk_broken_viewport_subpixel_bits()

static void quirk_broken_viewport_subpixel_bits ( struct wined3d_gl_info *  gl_info )

static

Definition at line 1076 of file directx.c.

{
    if (gl_info->supported[ARB_CLIP_CONTROL])
    {
        TRACE("Disabling ARB_clip_control.\n");
        gl_info->supported[ARB_CLIP_CONTROL] = FALSE;
    }
}

quirk_clip_varying()

static void quirk_clip_varying ( struct wined3d_gl_info *  gl_info )

static

Definition at line 1018 of file directx.c.

{
    gl_info->quirks |= WINED3D_QUIRK_GLSL_CLIP_VARYING;
}

quirk_disable_nvvp_clip()

static void quirk_disable_nvvp_clip ( struct wined3d_gl_info *  gl_info )

static

Definition at line 1028 of file directx.c.

{
    gl_info->quirks |= WINED3D_QUIRK_NV_CLIP_BROKEN;
}

quirk_fbo_tex_update()

static void quirk_fbo_tex_update ( struct wined3d_gl_info *  gl_info )

static

Definition at line 1033 of file directx.c.

{
    gl_info->quirks |= WINED3D_QUIRK_FBO_TEX_UPDATE;
}

quirk_infolog_spam()

static void quirk_infolog_spam ( struct wined3d_gl_info *  gl_info )

static

Definition at line 1043 of file directx.c.

{
    gl_info->quirks |= WINED3D_QUIRK_INFO_LOG_SPAM;
}

quirk_limited_tex_filtering()

static void quirk_limited_tex_filtering ( struct wined3d_gl_info *  gl_info )

static

Definition at line 1048 of file directx.c.

{
    /* Nvidia GeForce 6xxx and 7xxx support accelerated VTF only on a few
       selected texture formats. They are apparently the only DX9 class GPUs
       supporting VTF.
       Also, DX9-era GPUs are somewhat limited with float textures
       filtering and blending. */
    gl_info->quirks |= WINED3D_QUIRK_LIMITED_TEX_FILTERING;
}

quirk_no_np2()

static void quirk_no_np2 ( struct wined3d_gl_info *  gl_info )

static

Definition at line 978 of file directx.c.

{
    /*  The nVidia GeForceFX series reports OpenGL 2.0 capabilities with the latest drivers versions, but
     *  doesn't explicitly advertise the ARB_tex_npot extension in the GL extension string.
     *  This usually means that ARB_tex_npot is supported in hardware as long as the application is staying
     *  within the limits enforced by the ARB_texture_rectangle extension. This however is not true for the
     *  FX series, which instantly falls back to a slower software path as soon as ARB_tex_npot is used.
     *  We therefore completely remove ARB_tex_npot from the list of supported extensions.
     *
     *  Note that wine_normalized_texrect can't be used in this case because internally it uses ARB_tex_npot,
     *  triggering the software fallback. There is not much we can do here apart from disabling the
     *  software-emulated extension and re-enable ARB_tex_rect (which was previously disabled
     *  in wined3d_adapter_init_gl_caps).
     *  This fixup removes performance problems on both the FX 5900 and FX 5700 (e.g. for framebuffer
     *  post-processing effects in the game "Max Payne 2").
     *  The behaviour can be verified through a simple test app attached in bugreport #14724. */
    TRACE("GL_ARB_texture_non_power_of_two advertised through OpenGL 2.0 on NV FX card, removing.\n");
    gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
    gl_info->supported[ARB_TEXTURE_RECTANGLE] = TRUE;
}

quirk_r200_constants()

static void quirk_r200_constants ( struct wined3d_gl_info *  gl_info )

static

Definition at line 1058 of file directx.c.

{
    /* The Mesa r200 driver (and there is no other driver for this GPU Wine would run on)
     * loads some fog parameters (start, end, exponent, but not the color) into the
     * program.
     *
     * Apparently the fog hardware is only able to handle linear fog with a range of 0.0;1.0,
     * and it is the responsibility of the vertex pipeline to handle non-linear fog and
     * linear fog with start and end other than 0.0 and 1.0. */
    TRACE("Reserving 1 ARB constant for compiler private use.\n");
    gl_info->reserved_arb_constants = max(gl_info->reserved_arb_constants, 1);
}

quirk_texcoord_w()

static void quirk_texcoord_w ( struct wined3d_gl_info *  gl_info )

static

Definition at line 999 of file directx.c.

{
    /* The Intel GPUs on MacOS set the .w register of texcoords to 0.0 by default, which causes problems
     * with fixed function fragment processing. Ideally this flag should be detected with a test shader
     * and OpenGL feedback mode, but some GL implementations (MacOS ATI at least, probably all MacOS ones)
     * do not like vertex shaders in feedback mode and return an error, even though it should be valid
     * according to the spec.
     *
     * We don't want to enable this on all cards, as it adds an extra instruction per texcoord used. This
     * makes the shader slower and eats instruction slots which should be available to the d3d app.
     *
     * ATI Radeon HD 2xxx cards on MacOS have the issue. Instead of checking for the buggy cards, blacklist
     * all radeon cards on Macs and whitelist the good ones. That way we're prepared for the future. If
     * this workaround is activated on cards that do not need it, it won't break things, just affect
     * performance negatively. */
    TRACE("Enabling vertex texture coord fixes in vertex shaders.\n");
    gl_info->quirks |= WINED3D_QUIRK_SET_TEXCOORD_W;
}

select_card_handler()

static enum wined3d_pci_device select_card_handler ( const struct gl_vendor_selection *  table, unsigned int  table_size, enum wined3d_gl_vendor  gl_vendor, const char *  gl_renderer  )

static

Definition at line 2469 of file directx.c.

{
    unsigned int i, j;

    for (i = 0; i < table_size; ++i)
    {
        if (table[i].gl_vendor != gl_vendor)
            continue;

        TRACE("Applying card selector \"%s\".\n", table[i].description);

        for (j = 0; j < table[i].cards_size; ++j)
        {
            if (strstr(gl_renderer, table[i].cards[j].renderer))
                return table[i].cards[j].id;
        }
        return PCI_DEVICE_NONE;
    }
    FIXME("Couldn't find a suitable card selector for GL vendor %04x (using GL_RENDERER %s)\n",
            gl_vendor, debugstr_a(gl_renderer));

    return PCI_DEVICE_NONE;
}

Referenced by wined3d_guess_card().

select_fragment_implementation()

static const struct fragment_pipeline* select_fragment_implementation ( const struct wined3d_gl_info *  gl_info, const struct wined3d_shader_backend_ops *  shader_backend_ops  )

static

Definition at line 2607 of file directx.c.

{
    if (shader_backend_ops == &glsl_shader_backend && gl_info->supported[ARB_FRAGMENT_SHADER])
        return &glsl_fragment_pipe;
    if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
        return &arbfp_fragment_pipeline;
    if (gl_info->supported[ATI_FRAGMENT_SHADER])
        return &atifs_fragment_pipeline;
    if (gl_info->supported[NV_REGISTER_COMBINERS] && gl_info->supported[NV_TEXTURE_SHADER2])
        return &nvts_fragment_pipeline;
    if (gl_info->supported[NV_REGISTER_COMBINERS])
        return &nvrc_fragment_pipeline;
    return &ffp_fragment_pipeline;
}

Referenced by wined3d_adapter_init_gl_caps().

select_shader_backend()

static const struct wined3d_shader_backend_ops* select_shader_backend ( const struct wined3d_gl_info *  gl_info )

static

Definition at line 2623 of file directx.c.

{
    BOOL glsl = wined3d_settings.glslRequested && gl_info->glsl_version >= MAKEDWORD_VERSION(1, 20);

    if (glsl && gl_info->supported[ARB_VERTEX_SHADER] && gl_info->supported[ARB_FRAGMENT_SHADER])
        return &glsl_shader_backend;
    if (gl_info->supported[ARB_VERTEX_PROGRAM] && gl_info->supported[ARB_FRAGMENT_PROGRAM])
        return &arb_program_shader_backend;
    if (glsl && (gl_info->supported[ARB_VERTEX_SHADER] || gl_info->supported[ARB_FRAGMENT_SHADER]))
        return &glsl_shader_backend;
    if (gl_info->supported[ARB_VERTEX_PROGRAM] || gl_info->supported[ARB_FRAGMENT_PROGRAM])
        return &arb_program_shader_backend;
    return &none_shader_backend;
}

Referenced by wined3d_adapter_init_gl_caps().

select_vertex_implementation()

static const struct wined3d_vertex_pipe_ops* select_vertex_implementation ( const struct wined3d_gl_info *  gl_info, const struct wined3d_shader_backend_ops *  shader_backend_ops  )

static

Definition at line 2599 of file directx.c.

{
    if (shader_backend_ops == &glsl_shader_backend && gl_info->supported[ARB_VERTEX_SHADER])
        return &glsl_vertex_pipe;
    return &ffp_vertex_pipe;
}

Referenced by wined3d_adapter_init_gl_caps().

specular_d3dcolor()

static void WINE_GLAPI specular_d3dcolor ( const void *  data )

static

Definition at line 6337 of file directx.c.

{
    DWORD specularColor = *((const DWORD *)data);
    GLubyte d[] =
    {
        D3DCOLOR_B_R(specularColor),
        D3DCOLOR_B_G(specularColor),
        D3DCOLOR_B_B(specularColor)
    };

    context_get_current()->gl_info->gl_ops.ext.p_glSecondaryColor3ubvEXT(d);
}

Referenced by wined3d_adapter_init_ffp_attrib_ops().

test_arb_vs_offset_limit()

static BOOL test_arb_vs_offset_limit ( const struct wined3d_gl_info *  gl_info )

static

Definition at line 486 of file directx.c.

{
    GLuint prog;
    BOOL ret = FALSE;
    static const char testcode[] =
        "!!ARBvp1.0\n"
        "PARAM C[66] = { program.env[0..65] };\n"
        "ADDRESS A0;"
        "PARAM zero = {0.0, 0.0, 0.0, 0.0};\n"
        "ARL A0.x, zero.x;\n"
        "MOV result.position, C[A0.x + 65];\n"
        "END\n";

    while (gl_info->gl_ops.gl.p_glGetError());
    GL_EXTCALL(glGenProgramsARB(1, &prog));
    if(!prog) {
        ERR("Failed to create an ARB offset limit test program\n");
    }
    GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
    GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
                                  strlen(testcode), testcode));
    if (gl_info->gl_ops.gl.p_glGetError())
    {
        TRACE("OpenGL implementation does not allow indirect addressing offsets > 63\n");
        TRACE("error: %s\n", debugstr_a((const char *)gl_info->gl_ops.gl.p_glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
        ret = TRUE;
    } else TRACE("OpenGL implementation allows offsets > 63\n");

    GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
    GL_EXTCALL(glDeleteProgramsARB(1, &prog));
    checkGLcall("ARB vp offset limit test cleanup");

    return ret;
}

Referenced by wined3d_adapter_init_gl_caps().

test_pbo_functionality()

static void test_pbo_functionality ( struct wined3d_gl_info *  gl_info )

static

Definition at line 570 of file directx.c.

{
    /* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs,
     * but glTexSubImage from a PBO fails miserably, with the first line repeated over
     * all the texture. This function detects this bug by its symptom and disables PBOs
     * if the test fails.
     *
     * The test uploads a 4x4 texture via the PBO in the "native" format GL_BGRA,
     * GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use
     * for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data
     * read back is compared to the original. If they are equal PBOs are assumed to work,
     * otherwise the PBO extension is disabled. */
    GLuint texture, pbo;
    static const unsigned int pattern[] =
    {
        0x00000000, 0x000000ff, 0x0000ff00, 0x40ff0000,
        0x80ffffff, 0x40ffff00, 0x00ff00ff, 0x0000ffff,
        0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x000000ff,
        0x80ff00ff, 0x0000ffff, 0x00ff00ff, 0x40ff00ff
    };
    unsigned int check[ARRAY_SIZE(pattern)];

    /* No PBO -> No point in testing them. */
    if (!gl_info->supported[ARB_PIXEL_BUFFER_OBJECT]) return;

    while (gl_info->gl_ops.gl.p_glGetError());
    gl_info->gl_ops.gl.p_glGenTextures(1, &texture);
    gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, texture);

    gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
    gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0);
    checkGLcall("Specifying the PBO test texture");

    GL_EXTCALL(glGenBuffers(1, &pbo));
    GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo));
    GL_EXTCALL(glBufferData(GL_PIXEL_UNPACK_BUFFER, sizeof(pattern), pattern, GL_STREAM_DRAW));
    checkGLcall("Specifying the PBO test pbo");

    gl_info->gl_ops.gl.p_glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
    checkGLcall("Loading the PBO test texture");

    GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));

    gl_info->gl_ops.gl.p_glFinish(); /* just to be sure */

    memset(check, 0, sizeof(check));
    gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, check);
    checkGLcall("Reading back the PBO test texture");

    gl_info->gl_ops.gl.p_glDeleteTextures(1, &texture);
    GL_EXTCALL(glDeleteBuffers(1, &pbo));
    checkGLcall("PBO test cleanup");

    if (memcmp(check, pattern, sizeof(check)))
    {
        WARN_(d3d_perf)("PBO test failed, read back data doesn't match original.\n"
                "Disabling PBOs. This may result in slower performance.\n");
        gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] = FALSE;
    }
    else
    {
        TRACE("PBO test successful.\n");
    }
}

Referenced by fixup_extensions().

warn_no_specular_func()

static void WINE_GLAPI warn_no_specular_func ( const void *  data )

static

Definition at line 6350 of file directx.c.

{
    WARN("GL_EXT_secondary_color not supported.\n");
}

Referenced by wined3d_adapter_init_ffp_attrib_ops().

WINE_DECLARE_DEBUG_CHANNEL() [1/2]

WINE_DECLARE_DEBUG_CHANNEL

(

d3d_perf

)

WINE_DECLARE_DEBUG_CHANNEL() [2/2]

WINE_DECLARE_DEBUG_CHANNEL

(

winediag

)

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

d3d

)

wined3d_adapter_cleanup()

static void wined3d_adapter_cleanup ( struct wined3d_adapter *  adapter )

static

Definition at line 450 of file directx.c.

{
    heap_free(adapter->gl_info.formats);
    heap_free(adapter->cfgs);
}

Referenced by wined3d_decref().

wined3d_adapter_init()

static BOOL wined3d_adapter_init ( struct wined3d_adapter *  adapter, UINT  ordinal, DWORD  wined3d_creation_flags  )

static

Definition at line 6646 of file directx.c.

{
    static const DWORD supported_gl_versions[] =
    {
        MAKEDWORD_VERSION(4, 4),
        MAKEDWORD_VERSION(3, 2),
        MAKEDWORD_VERSION(1, 0),
    };
    struct wined3d_gl_info *gl_info = &adapter->gl_info;
    struct wined3d_caps_gl_ctx caps_gl_ctx = {0};
    unsigned int i;
    DISPLAY_DEVICEW display_device;
    DWORD max_gl_version;

    TRACE("adapter %p, ordinal %u.\n", adapter, ordinal);

    adapter->ordinal = ordinal;

/* Dynamically load all GL core functions */
#ifdef USE_WIN32_OPENGL
    {
        HMODULE mod_gl = GetModuleHandleA("opengl32.dll");
#define USE_GL_FUNC(f) gl_info->gl_ops.gl.p_##f = (void *)GetProcAddress(mod_gl, #f);
        ALL_WGL_FUNCS
#undef USE_GL_FUNC
        gl_info->gl_ops.wgl.p_wglSwapBuffers = (void *)GetProcAddress(mod_gl, "wglSwapBuffers");
        gl_info->gl_ops.wgl.p_wglGetPixelFormat = (void *)GetProcAddress(mod_gl, "wglGetPixelFormat");
    }
#else
    /* To bypass the opengl32 thunks retrieve functions from the WGL driver instead of opengl32 */
    {
        HDC hdc = GetDC( 0 );
        const struct opengl_funcs *wgl_driver = __wine_get_wgl_driver( hdc, WINE_WGL_DRIVER_VERSION );
        ReleaseDC( 0, hdc );
        if (!wgl_driver || wgl_driver == (void *)-1) return FALSE;
        gl_info->gl_ops.wgl = wgl_driver->wgl;
        gl_info->gl_ops.gl = wgl_driver->gl;
    }
#endif

    glEnableWINE = gl_info->gl_ops.gl.p_glEnable;
    glDisableWINE = gl_info->gl_ops.gl.p_glDisable;

    if (!AllocateLocallyUniqueId(&adapter->luid))
    {
        ERR("Failed to set adapter LUID (%#x).\n", GetLastError());
        return FALSE;
    }
    TRACE("Allocated LUID %08x:%08x for adapter %p.\n",
            adapter->luid.HighPart, adapter->luid.LowPart, adapter);

    if (!wined3d_caps_gl_ctx_create(adapter, &caps_gl_ctx))
    {
        ERR("Failed to get a GL context for adapter %p.\n", adapter);
        return FALSE;
    }

    max_gl_version = get_max_gl_version(gl_info, wined3d_creation_flags);

    if (wined3d_creation_flags & WINED3D_REQUEST_D3D10)
    {
        const char *gl_extensions = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_EXTENSIONS);
        if (!has_extension(gl_extensions, "GL_ARB_compatibility"))
        {
            ERR_(winediag)("GL_ARB_compatibility not supported, requesting context with GL version 3.2.\n");
            max_gl_version = MAKEDWORD_VERSION(3, 2);
        }
    }

    for (i = 0; i < ARRAY_SIZE(supported_gl_versions); ++i)
    {
        if (supported_gl_versions[i] <= max_gl_version)
            break;
    }
    if (i == ARRAY_SIZE(supported_gl_versions))
    {
        ERR_(winediag)("Requested invalid GL version %u.%u.\n",
                max_gl_version >> 16, max_gl_version & 0xffff);
        i = ARRAY_SIZE(supported_gl_versions) - 1;
    }

    for (; i < ARRAY_SIZE(supported_gl_versions); ++i)
    {
        gl_info->selected_gl_version = supported_gl_versions[i];

        if (wined3d_caps_gl_ctx_create_attribs(&caps_gl_ctx, gl_info))
            break;

        WARN("Couldn't create an OpenGL %u.%u context, trying fallback to a lower version.\n",
                supported_gl_versions[i] >> 16, supported_gl_versions[i] & 0xffff);
    }

    if (!wined3d_adapter_init_gl_caps(adapter, &caps_gl_ctx, wined3d_creation_flags))
    {
        ERR("Failed to initialize GL caps for adapter %p.\n", adapter);
        wined3d_caps_gl_ctx_destroy(&caps_gl_ctx);
        return FALSE;
    }

    if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER)
        ERR_(winediag)("You are using the backbuffer for offscreen rendering. "
                "This is unsupported, and will be removed in a future version.\n");

    wined3d_adapter_init_fb_cfgs(adapter, caps_gl_ctx.dc);
    /* We haven't found any suitable formats. This should only happen in
     * case of GDI software rendering, which is pretty useless anyway. */
    if (!adapter->cfg_count)
    {