1194 lines
42 KiB
C
1194 lines
42 KiB
C
|
/*
|
||
|
* Direct3D wine OpenGL include file
|
||
|
*
|
||
|
* Copyright 2002-2003 The wine-d3d team
|
||
|
* Copyright 2002-2004 Jason Edmeades
|
||
|
* Raphael Junqueira
|
||
|
* Copyright 2007 Roderick Colenbrander
|
||
|
*
|
||
|
* This library is free software; you can redistribute it and/or
|
||
|
* modify it under the terms of the GNU Lesser General Public
|
||
|
* License as published by the Free Software Foundation; either
|
||
|
* version 2.1 of the License, or (at your option) any later version.
|
||
|
*
|
||
|
* This library is distributed in the hope that it will be useful,
|
||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
|
* Lesser General Public License for more details.
|
||
|
*
|
||
|
* You should have received a copy of the GNU Lesser General Public
|
||
|
* License along with this library; if not, write to the Free Software
|
||
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
||
|
*/
|
||
|
|
||
|
#ifndef __WINE_WINED3D_GL_H
|
||
|
#define __WINE_WINED3D_GL_H
|
||
|
|
||
|
#define WINE_GLAPI __stdcall
|
||
|
|
||
|
#include <stdbool.h>
|
||
|
#include <stdint.h>
|
||
|
|
||
|
#include "wine/wgl.h"
|
||
|
#include "wine/wgl_driver.h"
|
||
|
|
||
|
struct wined3d_swapchain_gl;
|
||
|
struct wined3d_texture_gl;
|
||
|
|
||
|
#define GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI 0x8837 /* not in the gl spec */
|
||
|
|
||
|
/* OpenGL extensions. */
|
||
|
enum wined3d_gl_extension
|
||
|
{
|
||
|
WINED3D_GL_EXT_NONE,
|
||
|
|
||
|
/* APPLE */
|
||
|
APPLE_FENCE,
|
||
|
APPLE_FLOAT_PIXELS,
|
||
|
APPLE_FLUSH_BUFFER_RANGE,
|
||
|
APPLE_FLUSH_RENDER,
|
||
|
APPLE_RGB_422,
|
||
|
APPLE_YCBCR_422,
|
||
|
/* ARB */
|
||
|
ARB_BASE_INSTANCE,
|
||
|
ARB_BLEND_FUNC_EXTENDED,
|
||
|
ARB_BUFFER_STORAGE,
|
||
|
ARB_CLEAR_BUFFER_OBJECT,
|
||
|
ARB_CLEAR_TEXTURE,
|
||
|
ARB_CLIP_CONTROL,
|
||
|
ARB_COLOR_BUFFER_FLOAT,
|
||
|
ARB_COMPUTE_SHADER,
|
||
|
ARB_CONSERVATIVE_DEPTH,
|
||
|
ARB_COPY_BUFFER,
|
||
|
ARB_COPY_IMAGE,
|
||
|
ARB_CULL_DISTANCE,
|
||
|
ARB_DEBUG_OUTPUT,
|
||
|
ARB_DEPTH_BUFFER_FLOAT,
|
||
|
ARB_DEPTH_CLAMP,
|
||
|
ARB_DEPTH_TEXTURE,
|
||
|
ARB_DERIVATIVE_CONTROL,
|
||
|
ARB_DRAW_BUFFERS,
|
||
|
ARB_DRAW_BUFFERS_BLEND,
|
||
|
ARB_DRAW_ELEMENTS_BASE_VERTEX,
|
||
|
ARB_DRAW_INDIRECT,
|
||
|
ARB_DRAW_INSTANCED,
|
||
|
ARB_ES2_COMPATIBILITY,
|
||
|
ARB_ES3_COMPATIBILITY,
|
||
|
ARB_EXPLICIT_ATTRIB_LOCATION,
|
||
|
ARB_FRAGMENT_COORD_CONVENTIONS,
|
||
|
ARB_FRAGMENT_LAYER_VIEWPORT,
|
||
|
ARB_FRAGMENT_PROGRAM,
|
||
|
ARB_FRAGMENT_PROGRAM_SHADOW,
|
||
|
ARB_FRAGMENT_SHADER,
|
||
|
ARB_FRAMEBUFFER_NO_ATTACHMENTS,
|
||
|
ARB_FRAMEBUFFER_OBJECT,
|
||
|
ARB_FRAMEBUFFER_SRGB,
|
||
|
ARB_GEOMETRY_SHADER4,
|
||
|
ARB_GPU_SHADER5,
|
||
|
ARB_HALF_FLOAT_PIXEL,
|
||
|
ARB_HALF_FLOAT_VERTEX,
|
||
|
ARB_INSTANCED_ARRAYS,
|
||
|
ARB_INTERNALFORMAT_QUERY,
|
||
|
ARB_INTERNALFORMAT_QUERY2,
|
||
|
ARB_MAP_BUFFER_ALIGNMENT,
|
||
|
ARB_MAP_BUFFER_RANGE,
|
||
|
ARB_MULTISAMPLE,
|
||
|
ARB_MULTITEXTURE,
|
||
|
ARB_OCCLUSION_QUERY,
|
||
|
ARB_PIPELINE_STATISTICS_QUERY,
|
||
|
ARB_PIXEL_BUFFER_OBJECT,
|
||
|
ARB_POINT_PARAMETERS,
|
||
|
ARB_POINT_SPRITE,
|
||
|
ARB_POLYGON_OFFSET_CLAMP,
|
||
|
ARB_PROVOKING_VERTEX,
|
||
|
ARB_QUERY_BUFFER_OBJECT,
|
||
|
ARB_SAMPLE_SHADING,
|
||
|
ARB_SAMPLER_OBJECTS,
|
||
|
ARB_SEAMLESS_CUBE_MAP,
|
||
|
ARB_SHADER_ATOMIC_COUNTERS,
|
||
|
ARB_SHADER_VIEWPORT_LAYER_ARRAY,
|
||
|
ARB_SHADER_BIT_ENCODING,
|
||
|
ARB_SHADER_IMAGE_LOAD_STORE,
|
||
|
ARB_SHADER_IMAGE_SIZE,
|
||
|
ARB_SHADER_STENCIL_EXPORT,
|
||
|
ARB_SHADER_STORAGE_BUFFER_OBJECT,
|
||
|
ARB_SHADER_TEXTURE_IMAGE_SAMPLES,
|
||
|
ARB_SHADER_TEXTURE_LOD,
|
||
|
ARB_SHADING_LANGUAGE_100,
|
||
|
ARB_SHADING_LANGUAGE_420PACK,
|
||
|
ARB_SHADING_LANGUAGE_PACKING,
|
||
|
ARB_SHADOW,
|
||
|
ARB_STENCIL_TEXTURING,
|
||
|
ARB_SYNC,
|
||
|
ARB_TESSELLATION_SHADER,
|
||
|
ARB_TEXTURE_BORDER_CLAMP,
|
||
|
ARB_TEXTURE_BUFFER_OBJECT,
|
||
|
ARB_TEXTURE_BUFFER_RANGE,
|
||
|
ARB_TEXTURE_COMPRESSION,
|
||
|
ARB_TEXTURE_COMPRESSION_BPTC,
|
||
|
ARB_TEXTURE_COMPRESSION_RGTC,
|
||
|
ARB_TEXTURE_CUBE_MAP,
|
||
|
ARB_TEXTURE_CUBE_MAP_ARRAY,
|
||
|
ARB_TEXTURE_ENV_COMBINE,
|
||
|
ARB_TEXTURE_ENV_DOT3,
|
||
|
ARB_TEXTURE_FILTER_ANISOTROPIC,
|
||
|
ARB_TEXTURE_FLOAT,
|
||
|
ARB_TEXTURE_GATHER,
|
||
|
ARB_TEXTURE_MIRRORED_REPEAT,
|
||
|
ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE,
|
||
|
ARB_TEXTURE_MULTISAMPLE,
|
||
|
ARB_TEXTURE_NON_POWER_OF_TWO,
|
||
|
ARB_TEXTURE_QUERY_LEVELS,
|
||
|
ARB_TEXTURE_RECTANGLE,
|
||
|
ARB_TEXTURE_RG,
|
||
|
ARB_TEXTURE_RGB10_A2UI,
|
||
|
ARB_TEXTURE_STORAGE,
|
||
|
ARB_TEXTURE_STORAGE_MULTISAMPLE,
|
||
|
ARB_TEXTURE_SWIZZLE,
|
||
|
ARB_TEXTURE_VIEW,
|
||
|
ARB_TIMER_QUERY,
|
||
|
ARB_TRANSFORM_FEEDBACK2,
|
||
|
ARB_TRANSFORM_FEEDBACK3,
|
||
|
ARB_UNIFORM_BUFFER_OBJECT,
|
||
|
ARB_VERTEX_ARRAY_BGRA,
|
||
|
ARB_VERTEX_BUFFER_OBJECT,
|
||
|
ARB_VERTEX_PROGRAM,
|
||
|
ARB_VERTEX_SHADER,
|
||
|
ARB_VERTEX_TYPE_10F_11F_11F_REV,
|
||
|
ARB_VERTEX_TYPE_2_10_10_10_REV,
|
||
|
ARB_VIEWPORT_ARRAY,
|
||
|
ARB_TEXTURE_BARRIER,
|
||
|
/* ATI */
|
||
|
ATI_FRAGMENT_SHADER,
|
||
|
ATI_SEPARATE_STENCIL,
|
||
|
ATI_TEXTURE_COMPRESSION_3DC,
|
||
|
ATI_TEXTURE_ENV_COMBINE3,
|
||
|
ATI_TEXTURE_MIRROR_ONCE,
|
||
|
/* EXT */
|
||
|
EXT_BLEND_COLOR,
|
||
|
EXT_BLEND_EQUATION_SEPARATE,
|
||
|
EXT_BLEND_FUNC_SEPARATE,
|
||
|
EXT_BLEND_MINMAX,
|
||
|
EXT_BLEND_SUBTRACT,
|
||
|
EXT_DEPTH_BOUNDS_TEST,
|
||
|
EXT_DRAW_BUFFERS2,
|
||
|
EXT_FOG_COORD,
|
||
|
EXT_FRAMEBUFFER_BLIT,
|
||
|
EXT_FRAMEBUFFER_MULTISAMPLE,
|
||
|
EXT_FRAMEBUFFER_MULTISAMPLE_BLIT_SCALED,
|
||
|
EXT_FRAMEBUFFER_OBJECT,
|
||
|
EXT_GPU_PROGRAM_PARAMETERS,
|
||
|
EXT_GPU_SHADER4,
|
||
|
EXT_MEMORY_OBJECT,
|
||
|
EXT_PACKED_DEPTH_STENCIL,
|
||
|
EXT_PACKED_FLOAT,
|
||
|
EXT_POINT_PARAMETERS,
|
||
|
EXT_PROVOKING_VERTEX,
|
||
|
EXT_SECONDARY_COLOR,
|
||
|
EXT_SHADER_INTEGER_MIX,
|
||
|
EXT_STENCIL_TWO_SIDE,
|
||
|
EXT_STENCIL_WRAP,
|
||
|
EXT_TEXTURE3D,
|
||
|
EXT_TEXTURE_ARRAY,
|
||
|
EXT_TEXTURE_COMPRESSION_RGTC,
|
||
|
EXT_TEXTURE_COMPRESSION_S3TC,
|
||
|
EXT_TEXTURE_ENV_COMBINE,
|
||
|
EXT_TEXTURE_ENV_DOT3,
|
||
|
EXT_TEXTURE_INTEGER,
|
||
|
EXT_TEXTURE_LOD_BIAS,
|
||
|
EXT_TEXTURE_MIRROR_CLAMP,
|
||
|
EXT_TEXTURE_SHADOW_LOD,
|
||
|
EXT_TEXTURE_SHARED_EXPONENT,
|
||
|
EXT_TEXTURE_SNORM,
|
||
|
EXT_TEXTURE_SRGB,
|
||
|
EXT_TEXTURE_SRGB_DECODE,
|
||
|
/* NVIDIA */
|
||
|
NV_FENCE,
|
||
|
NV_FOG_DISTANCE,
|
||
|
NV_FRAGMENT_PROGRAM,
|
||
|
NV_FRAGMENT_PROGRAM2,
|
||
|
NV_FRAGMENT_PROGRAM_OPTION,
|
||
|
NV_HALF_FLOAT,
|
||
|
NV_LIGHT_MAX_EXPONENT,
|
||
|
NV_POINT_SPRITE,
|
||
|
NV_REGISTER_COMBINERS,
|
||
|
NV_REGISTER_COMBINERS2,
|
||
|
NV_TEXGEN_REFLECTION,
|
||
|
NV_TEXTURE_ENV_COMBINE4,
|
||
|
NV_TEXTURE_SHADER,
|
||
|
NV_TEXTURE_SHADER2,
|
||
|
NV_VERTEX_PROGRAM,
|
||
|
NV_VERTEX_PROGRAM1_1,
|
||
|
NV_VERTEX_PROGRAM2,
|
||
|
NV_VERTEX_PROGRAM2_OPTION,
|
||
|
NV_VERTEX_PROGRAM3,
|
||
|
NV_TEXTURE_BARRIER,
|
||
|
/* WGL extensions */
|
||
|
WGL_ARB_PIXEL_FORMAT,
|
||
|
WGL_EXT_SWAP_CONTROL,
|
||
|
WGL_WINE_PIXEL_FORMAT_PASSTHROUGH,
|
||
|
WGL_WINE_QUERY_RENDERER,
|
||
|
/* Internally used */
|
||
|
WINED3D_GL_BLEND_EQUATION,
|
||
|
WINED3D_GL_LEGACY_CONTEXT,
|
||
|
WINED3D_GL_NORMALIZED_TEXRECT,
|
||
|
WINED3D_GL_PRIMITIVE_QUERY,
|
||
|
WINED3D_GL_VERSION_2_0,
|
||
|
WINED3D_GL_VERSION_3_2,
|
||
|
WINED3D_GLSL_130,
|
||
|
|
||
|
WINED3D_GL_EXT_COUNT,
|
||
|
};
|
||
|
|
||
|
struct wined3d_fbo_ops
|
||
|
{
|
||
|
GLboolean (WINE_GLAPI *glIsRenderbuffer)(GLuint renderbuffer);
|
||
|
void (WINE_GLAPI *glBindRenderbuffer)(GLenum target, GLuint renderbuffer);
|
||
|
void (WINE_GLAPI *glDeleteRenderbuffers)(GLsizei n, const GLuint *renderbuffers);
|
||
|
void (WINE_GLAPI *glGenRenderbuffers)(GLsizei n, GLuint *renderbuffers);
|
||
|
void (WINE_GLAPI *glRenderbufferStorage)(GLenum target, GLenum internalformat,
|
||
|
GLsizei width, GLsizei height);
|
||
|
void (WINE_GLAPI *glRenderbufferStorageMultisample)(GLenum target, GLsizei samples,
|
||
|
GLenum internalformat, GLsizei width, GLsizei height);
|
||
|
void (WINE_GLAPI *glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint *params);
|
||
|
GLboolean (WINE_GLAPI *glIsFramebuffer)(GLuint framebuffer);
|
||
|
void (WINE_GLAPI *glBindFramebuffer)(GLenum target, GLuint framebuffer);
|
||
|
void (WINE_GLAPI *glDeleteFramebuffers)(GLsizei n, const GLuint *framebuffers);
|
||
|
void (WINE_GLAPI *glGenFramebuffers)(GLsizei n, GLuint *framebuffers);
|
||
|
GLenum (WINE_GLAPI *glCheckFramebufferStatus)(GLenum target);
|
||
|
void (WINE_GLAPI *glFramebufferTexture)(GLenum target, GLenum attachment,
|
||
|
GLuint texture, GLint level);
|
||
|
void (WINE_GLAPI *glFramebufferTexture1D)(GLenum target, GLenum attachment,
|
||
|
GLenum textarget, GLuint texture, GLint level);
|
||
|
void (WINE_GLAPI *glFramebufferTexture2D)(GLenum target, GLenum attachment,
|
||
|
GLenum textarget, GLuint texture, GLint level);
|
||
|
void (WINE_GLAPI *glFramebufferTexture3D)(GLenum target, GLenum attachment,
|
||
|
GLenum textarget, GLuint texture, GLint level, GLint layer);
|
||
|
void (WINE_GLAPI *glFramebufferTextureLayer)(GLenum target, GLenum attachment,
|
||
|
GLuint texture, GLint level, GLint layer);
|
||
|
void (WINE_GLAPI *glFramebufferRenderbuffer)(GLenum target, GLenum attachment,
|
||
|
GLenum renderbuffertarget, GLuint renderbuffer);
|
||
|
void (WINE_GLAPI *glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment,
|
||
|
GLenum pname, GLint *params);
|
||
|
void (WINE_GLAPI *glBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
|
||
|
GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
|
||
|
void (WINE_GLAPI *glGenerateMipmap)(GLenum target);
|
||
|
};
|
||
|
|
||
|
struct wined3d_gl_limits
|
||
|
{
|
||
|
unsigned int buffers;
|
||
|
unsigned int lights;
|
||
|
unsigned int ffp_textures;
|
||
|
unsigned int texture_coords;
|
||
|
unsigned int uniform_blocks[WINED3D_SHADER_TYPE_COUNT];
|
||
|
unsigned int samplers[WINED3D_SHADER_TYPE_COUNT];
|
||
|
unsigned int graphics_samplers;
|
||
|
unsigned int combined_samplers;
|
||
|
unsigned int general_combiners;
|
||
|
unsigned int user_clip_distances;
|
||
|
unsigned int texture_size;
|
||
|
unsigned int texture3d_size;
|
||
|
unsigned int anisotropy;
|
||
|
float shininess;
|
||
|
unsigned int samples;
|
||
|
unsigned int vertex_attribs;
|
||
|
|
||
|
unsigned int texture_buffer_offset_alignment;
|
||
|
|
||
|
unsigned int framebuffer_width;
|
||
|
unsigned int framebuffer_height;
|
||
|
unsigned int viewport_subpixel_bits;
|
||
|
|
||
|
unsigned int glsl_varyings;
|
||
|
unsigned int glsl_vs_float_constants;
|
||
|
unsigned int glsl_ps_float_constants;
|
||
|
|
||
|
unsigned int arb_vs_float_constants;
|
||
|
unsigned int arb_vs_native_constants;
|
||
|
unsigned int arb_vs_instructions;
|
||
|
unsigned int arb_vs_temps;
|
||
|
unsigned int arb_ps_float_constants;
|
||
|
unsigned int arb_ps_local_constants;
|
||
|
unsigned int arb_ps_native_constants;
|
||
|
unsigned int arb_ps_instructions;
|
||
|
unsigned int arb_ps_temps;
|
||
|
};
|
||
|
|
||
|
void wined3d_gl_limits_get_texture_unit_range(const struct wined3d_gl_limits *gl_limits,
|
||
|
enum wined3d_shader_type shader_type, unsigned int *base, unsigned int *count);
|
||
|
void wined3d_gl_limits_get_uniform_block_range(const struct wined3d_gl_limits *gl_limits,
|
||
|
enum wined3d_shader_type shader_type, unsigned int *base, unsigned int *count);
|
||
|
|
||
|
#define WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT 0x00000001
|
||
|
#define WINED3D_QUIRK_GLSL_CLIP_VARYING 0x00000004
|
||
|
#define WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA 0x00000008
|
||
|
#define WINED3D_QUIRK_NV_CLIP_BROKEN 0x00000010
|
||
|
#define WINED3D_QUIRK_FBO_TEX_UPDATE 0x00000020
|
||
|
#define WINED3D_QUIRK_BROKEN_RGBA16 0x00000040
|
||
|
#define WINED3D_QUIRK_INFO_LOG_SPAM 0x00000080
|
||
|
#define WINED3D_QUIRK_LIMITED_TEX_FILTERING 0x00000100
|
||
|
#define WINED3D_QUIRK_BROKEN_ARB_FOG 0x00000200
|
||
|
#define WINED3D_QUIRK_NO_INDEPENDENT_BIT_DEPTHS 0x00000400
|
||
|
|
||
|
typedef void (WINE_GLAPI *wined3d_ffp_attrib_func)(const void *data);
|
||
|
typedef void (WINE_GLAPI *wined3d_ffp_texcoord_func)(GLenum unit, const void *data);
|
||
|
typedef void (WINE_GLAPI *wined3d_generic_attrib_func)(GLuint idx, const void *data);
|
||
|
|
||
|
struct wined3d_ffp_attrib_ops
|
||
|
{
|
||
|
wined3d_ffp_attrib_func position[WINED3D_FFP_EMIT_COUNT];
|
||
|
wined3d_ffp_attrib_func diffuse[WINED3D_FFP_EMIT_COUNT];
|
||
|
wined3d_ffp_attrib_func specular[WINED3D_FFP_EMIT_COUNT];
|
||
|
wined3d_ffp_attrib_func normal[WINED3D_FFP_EMIT_COUNT];
|
||
|
wined3d_ffp_texcoord_func texcoord[WINED3D_FFP_EMIT_COUNT];
|
||
|
wined3d_generic_attrib_func generic[WINED3D_FFP_EMIT_COUNT];
|
||
|
};
|
||
|
|
||
|
struct wined3d_gl_info
|
||
|
{
|
||
|
unsigned int selected_gl_version;
|
||
|
unsigned int glsl_version;
|
||
|
struct wined3d_gl_limits limits;
|
||
|
unsigned int reserved_glsl_constants, reserved_arb_constants;
|
||
|
uint32_t quirks;
|
||
|
BOOL supported[WINED3D_GL_EXT_COUNT];
|
||
|
GLint wrap_lookup[WINED3D_TADDRESS_MIRROR_ONCE - WINED3D_TADDRESS_WRAP + 1];
|
||
|
float filling_convention_offset;
|
||
|
|
||
|
HGLRC (WINAPI *p_wglCreateContextAttribsARB)(HDC dc, HGLRC share, const GLint *attribs);
|
||
|
struct wined3d_ffp_attrib_ops ffp_attrib_ops;
|
||
|
struct opengl_funcs gl_ops;
|
||
|
struct wined3d_fbo_ops fbo_ops;
|
||
|
|
||
|
void (WINE_GLAPI *p_glDisableWINE)(GLenum cap);
|
||
|
void (WINE_GLAPI *p_glEnableWINE)(GLenum cap);
|
||
|
};
|
||
|
|
||
|
void install_gl_compat_wrapper(struct wined3d_gl_info *gl_info, enum wined3d_gl_extension ext);
|
||
|
void print_glsl_info_log(const struct wined3d_gl_info *gl_info, GLuint id, BOOL program);
|
||
|
void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d_state *state,
|
||
|
BOOL is_alpha, int stage, enum wined3d_texture_op op, uint32_t arg1, uint32_t arg2, uint32_t arg3,
|
||
|
int texture_idx, DWORD dst);
|
||
|
void shader_glsl_validate_link(const struct wined3d_gl_info *gl_info, GLuint program);
|
||
|
void texture_activate_dimensions(struct wined3d_texture *texture, const struct wined3d_gl_info *gl_info);
|
||
|
GLenum wined3d_buffer_gl_binding_from_bind_flags(const struct wined3d_gl_info *gl_info, uint32_t bind_flags);
|
||
|
void wined3d_check_gl_call(const struct wined3d_gl_info *gl_info,
|
||
|
const char *file, unsigned int line, const char *name);
|
||
|
|
||
|
struct min_lookup
|
||
|
{
|
||
|
GLenum mip[WINED3D_TEXF_LINEAR + 1];
|
||
|
};
|
||
|
|
||
|
extern const struct min_lookup minMipLookup[WINED3D_TEXF_LINEAR + 1];
|
||
|
extern const GLenum magLookup[WINED3D_TEXF_LINEAR + 1];
|
||
|
|
||
|
static inline GLenum wined3d_gl_mag_filter(enum wined3d_texture_filter_type mag_filter)
|
||
|
{
|
||
|
return magLookup[mag_filter];
|
||
|
}
|
||
|
|
||
|
static inline GLenum wined3d_gl_min_mip_filter(enum wined3d_texture_filter_type min_filter,
|
||
|
enum wined3d_texture_filter_type mip_filter)
|
||
|
{
|
||
|
return minMipLookup[min_filter].mip[mip_filter];
|
||
|
}
|
||
|
|
||
|
GLenum wined3d_gl_compare_func(enum wined3d_cmp_func f);
|
||
|
|
||
|
const char *debug_fboattachment(GLenum attachment);
|
||
|
const char *debug_fbostatus(GLenum status);
|
||
|
const char *debug_glerror(GLenum error);
|
||
|
|
||
|
static inline bool wined3d_fence_supported(const struct wined3d_gl_info *gl_info)
|
||
|
{
|
||
|
return gl_info->supported[ARB_SYNC] || gl_info->supported[NV_FENCE] || gl_info->supported[APPLE_FENCE];
|
||
|
}
|
||
|
|
||
|
/* Checking of API calls */
|
||
|
/* --------------------- */
|
||
|
#ifndef WINE_NO_DEBUG_MSGS
|
||
|
#define checkGLcall(A) \
|
||
|
do \
|
||
|
{ \
|
||
|
if (__WINE_IS_DEBUG_ON(_ERR, &__wine_dbch_d3d) \
|
||
|
&& !gl_info->supported[ARB_DEBUG_OUTPUT]) \
|
||
|
wined3d_check_gl_call(gl_info, __FILE__, __LINE__, A); \
|
||
|
} while(0)
|
||
|
#else
|
||
|
#define checkGLcall(A) do {} while(0)
|
||
|
#endif
|
||
|
|
||
|
struct wined3d_bo_gl
|
||
|
{
|
||
|
struct wined3d_bo b;
|
||
|
|
||
|
GLuint id;
|
||
|
|
||
|
struct wined3d_allocator_block *memory;
|
||
|
|
||
|
GLsizeiptr size;
|
||
|
GLenum binding;
|
||
|
GLenum usage;
|
||
|
|
||
|
GLbitfield flags;
|
||
|
uint64_t command_fence_id;
|
||
|
};
|
||
|
|
||
|
static inline struct wined3d_bo_gl *wined3d_bo_gl(struct wined3d_bo *bo)
|
||
|
{
|
||
|
return CONTAINING_RECORD(bo, struct wined3d_bo_gl, b);
|
||
|
}
|
||
|
|
||
|
static inline GLuint wined3d_bo_gl_id(struct wined3d_bo *bo)
|
||
|
{
|
||
|
return bo ? wined3d_bo_gl(bo)->id : 0;
|
||
|
}
|
||
|
|
||
|
union wined3d_gl_fence_object
|
||
|
{
|
||
|
GLuint id;
|
||
|
GLsync sync;
|
||
|
};
|
||
|
|
||
|
enum wined3d_fence_result
|
||
|
{
|
||
|
WINED3D_FENCE_OK,
|
||
|
WINED3D_FENCE_WAITING,
|
||
|
WINED3D_FENCE_NOT_STARTED,
|
||
|
WINED3D_FENCE_WRONG_THREAD,
|
||
|
WINED3D_FENCE_ERROR,
|
||
|
};
|
||
|
|
||
|
struct wined3d_fence
|
||
|
{
|
||
|
struct list entry;
|
||
|
union wined3d_gl_fence_object object;
|
||
|
struct wined3d_context_gl *context_gl;
|
||
|
};
|
||
|
|
||
|
HRESULT wined3d_fence_create(struct wined3d_device *device, struct wined3d_fence **fence);
|
||
|
void wined3d_fence_destroy(struct wined3d_fence *fence);
|
||
|
void wined3d_fence_issue(struct wined3d_fence *fence, struct wined3d_device *device);
|
||
|
enum wined3d_fence_result wined3d_fence_wait(const struct wined3d_fence *fence, struct wined3d_device *device);
|
||
|
enum wined3d_fence_result wined3d_fence_test(const struct wined3d_fence *fence,
|
||
|
struct wined3d_device *device, uint32_t flags);
|
||
|
|
||
|
HRESULT wined3d_query_gl_create(struct wined3d_device *device, enum wined3d_query_type type, void *parent,
|
||
|
const struct wined3d_parent_ops *parent_ops, struct wined3d_query **query);
|
||
|
void wined3d_query_gl_destroy_buffer_object(struct wined3d_context_gl *context_gl, struct wined3d_query *query);
|
||
|
|
||
|
struct wined3d_event_query
|
||
|
{
|
||
|
struct wined3d_query query;
|
||
|
|
||
|
struct wined3d_fence fence;
|
||
|
BOOL signalled;
|
||
|
};
|
||
|
|
||
|
struct wined3d_occlusion_query
|
||
|
{
|
||
|
struct wined3d_query query;
|
||
|
|
||
|
struct list entry;
|
||
|
GLuint id;
|
||
|
struct wined3d_context_gl *context_gl;
|
||
|
uint64_t samples;
|
||
|
BOOL started;
|
||
|
};
|
||
|
|
||
|
struct wined3d_timestamp_query
|
||
|
{
|
||
|
struct wined3d_query query;
|
||
|
|
||
|
struct list entry;
|
||
|
GLuint id;
|
||
|
struct wined3d_context_gl *context_gl;
|
||
|
uint64_t timestamp;
|
||
|
};
|
||
|
|
||
|
union wined3d_gl_so_statistics_query
|
||
|
{
|
||
|
GLuint id[2];
|
||
|
struct
|
||
|
{
|
||
|
GLuint written;
|
||
|
GLuint generated;
|
||
|
} query;
|
||
|
};
|
||
|
|
||
|
struct wined3d_so_statistics_query
|
||
|
{
|
||
|
struct wined3d_query query;
|
||
|
|
||
|
struct list entry;
|
||
|
union wined3d_gl_so_statistics_query u;
|
||
|
struct wined3d_context_gl *context_gl;
|
||
|
unsigned int stream_idx;
|
||
|
struct wined3d_query_data_so_statistics statistics;
|
||
|
BOOL started;
|
||
|
};
|
||
|
|
||
|
union wined3d_gl_pipeline_statistics_query
|
||
|
{
|
||
|
GLuint id[11];
|
||
|
struct
|
||
|
{
|
||
|
GLuint vertices;
|
||
|
GLuint primitives;
|
||
|
GLuint vertex_shader;
|
||
|
GLuint tess_control_shader;
|
||
|
GLuint tess_eval_shader;
|
||
|
GLuint geometry_shader;
|
||
|
GLuint geometry_primitives;
|
||
|
GLuint fragment_shader;
|
||
|
GLuint compute_shader;
|
||
|
GLuint clipping_input;
|
||
|
GLuint clipping_output;
|
||
|
} query;
|
||
|
};
|
||
|
|
||
|
struct wined3d_pipeline_statistics_query
|
||
|
{
|
||
|
struct wined3d_query query;
|
||
|
|
||
|
struct list entry;
|
||
|
union wined3d_gl_pipeline_statistics_query u;
|
||
|
struct wined3d_context_gl *context_gl;
|
||
|
struct wined3d_query_data_pipeline_statistics statistics;
|
||
|
BOOL started;
|
||
|
};
|
||
|
|
||
|
struct wined3d_gl_view
|
||
|
{
|
||
|
GLenum target;
|
||
|
GLuint name;
|
||
|
};
|
||
|
|
||
|
struct wined3d_rendertarget_info
|
||
|
{
|
||
|
struct wined3d_gl_view gl_view;
|
||
|
struct wined3d_resource *resource;
|
||
|
unsigned int sub_resource_idx;
|
||
|
unsigned int layer_count;
|
||
|
};
|
||
|
|
||
|
struct wined3d_command_fence_gl
|
||
|
{
|
||
|
uint64_t id;
|
||
|
struct wined3d_fence *fence;
|
||
|
};
|
||
|
|
||
|
#define MAX_GL_FRAGMENT_SAMPLERS 32
|
||
|
|
||
|
struct wined3d_fbo_resource
|
||
|
{
|
||
|
GLuint object;
|
||
|
GLenum target;
|
||
|
GLuint level, layer;
|
||
|
};
|
||
|
|
||
|
#define WINED3D_FBO_ENTRY_FLAG_ATTACHED 0x1
|
||
|
#define WINED3D_FBO_ENTRY_FLAG_DEPTH 0x2
|
||
|
#define WINED3D_FBO_ENTRY_FLAG_STENCIL 0x4
|
||
|
|
||
|
struct fbo_entry
|
||
|
{
|
||
|
struct list entry;
|
||
|
uint32_t flags;
|
||
|
uint32_t rt_mask;
|
||
|
GLuint id;
|
||
|
struct wined3d_fbo_entry_key
|
||
|
{
|
||
|
uint32_t rb_namespace;
|
||
|
struct wined3d_fbo_resource objects[WINED3D_MAX_RENDER_TARGETS + 1];
|
||
|
} key;
|
||
|
};
|
||
|
|
||
|
struct wined3d_context_gl
|
||
|
{
|
||
|
struct wined3d_context c;
|
||
|
|
||
|
const struct wined3d_gl_info *gl_info;
|
||
|
|
||
|
DWORD tid; /* Thread ID which owns this context at the moment. */
|
||
|
|
||
|
uint32_t dc_is_private : 1;
|
||
|
uint32_t dc_has_format : 1; /* Only meaningful for private DCs. */
|
||
|
uint32_t fog_enabled : 1;
|
||
|
uint32_t diffuse_attrib_to_1 : 1;
|
||
|
uint32_t rebind_fbo : 1;
|
||
|
uint32_t untracked_material_count : 2; /* Max value 2 */
|
||
|
uint32_t needs_set : 1;
|
||
|
uint32_t internal_format_set : 1;
|
||
|
uint32_t valid : 1;
|
||
|
uint32_t padding : 22;
|
||
|
|
||
|
uint32_t default_attrib_value_set;
|
||
|
|
||
|
GLenum tracking_parm; /* Which source is tracking current colour. */
|
||
|
GLenum untracked_materials[2];
|
||
|
SIZE blit_size;
|
||
|
unsigned int active_texture;
|
||
|
|
||
|
GLenum *texture_type;
|
||
|
|
||
|
/* The WGL context. */
|
||
|
unsigned int level;
|
||
|
HGLRC restore_ctx;
|
||
|
HDC restore_dc;
|
||
|
int restore_pf;
|
||
|
HWND restore_pf_win;
|
||
|
HGLRC gl_ctx;
|
||
|
HDC dc;
|
||
|
int pixel_format;
|
||
|
HWND window;
|
||
|
GLint aux_buffers;
|
||
|
|
||
|
/* FBOs. */
|
||
|
unsigned int fbo_entry_count;
|
||
|
struct list fbo_list;
|
||
|
struct list fbo_destroy_list;
|
||
|
struct fbo_entry *current_fbo;
|
||
|
GLuint fbo_read_binding;
|
||
|
GLuint fbo_draw_binding;
|
||
|
struct wined3d_rendertarget_info blit_targets[WINED3D_MAX_RENDER_TARGETS];
|
||
|
uint32_t draw_buffers_mask; /* Enabled draw buffers, 31 max. */
|
||
|
|
||
|
/* Queries. */
|
||
|
struct list occlusion_queries;
|
||
|
struct list fences;
|
||
|
struct list timestamp_queries;
|
||
|
struct list so_statistics_queries;
|
||
|
struct list pipeline_statistics_queries;
|
||
|
|
||
|
GLuint *free_occlusion_queries;
|
||
|
SIZE_T free_occlusion_query_size;
|
||
|
unsigned int free_occlusion_query_count;
|
||
|
|
||
|
union wined3d_gl_fence_object *free_fences;
|
||
|
SIZE_T free_fence_size;
|
||
|
unsigned int free_fence_count;
|
||
|
|
||
|
GLuint *free_timestamp_queries;
|
||
|
SIZE_T free_timestamp_query_size;
|
||
|
unsigned int free_timestamp_query_count;
|
||
|
|
||
|
union wined3d_gl_so_statistics_query *free_so_statistics_queries;
|
||
|
SIZE_T free_so_statistics_query_size;
|
||
|
unsigned int free_so_statistics_query_count;
|
||
|
|
||
|
union wined3d_gl_pipeline_statistics_query *free_pipeline_statistics_queries;
|
||
|
SIZE_T free_pipeline_statistics_query_size;
|
||
|
unsigned int free_pipeline_statistics_query_count;
|
||
|
|
||
|
GLuint blit_vbo;
|
||
|
|
||
|
unsigned int tex_unit_map[WINED3D_MAX_COMBINED_SAMPLERS];
|
||
|
unsigned int rev_tex_unit_map[MAX_GL_FRAGMENT_SAMPLERS + WINED3D_MAX_VERTEX_SAMPLERS];
|
||
|
|
||
|
/* Extension emulation. */
|
||
|
GLint gl_fog_source;
|
||
|
GLfloat fog_coord_value;
|
||
|
GLfloat colour[4], fog_start, fog_end, fog_colour[4];
|
||
|
|
||
|
GLuint dummy_arbfp_prog;
|
||
|
|
||
|
struct
|
||
|
{
|
||
|
struct wined3d_command_fence_gl *fences;
|
||
|
SIZE_T fences_size;
|
||
|
SIZE_T fence_count;
|
||
|
} submitted;
|
||
|
};
|
||
|
|
||
|
static inline struct wined3d_context_gl *wined3d_context_gl(struct wined3d_context *context)
|
||
|
{
|
||
|
return CONTAINING_RECORD(context, struct wined3d_context_gl, c);
|
||
|
}
|
||
|
|
||
|
static inline const struct wined3d_context_gl *wined3d_context_gl_const(const struct wined3d_context *context)
|
||
|
{
|
||
|
return CONTAINING_RECORD(context, struct wined3d_context_gl, c);
|
||
|
}
|
||
|
|
||
|
HGLRC context_create_wgl_attribs(const struct wined3d_gl_info *gl_info, HDC hdc, HGLRC share_ctx);
|
||
|
DWORD context_get_tls_idx(void);
|
||
|
void context_gl_apply_texture_draw_state(struct wined3d_context_gl *context_gl,
|
||
|
struct wined3d_texture *texture, unsigned int sub_resource_idx, unsigned int location);
|
||
|
void context_gl_resource_released(struct wined3d_device *device, GLuint name, BOOL rb_namespace);
|
||
|
|
||
|
struct wined3d_context *wined3d_context_gl_acquire(const struct wined3d_device *device,
|
||
|
struct wined3d_texture *texture, unsigned int sub_resource_idx);
|
||
|
void wined3d_context_gl_active_texture(struct wined3d_context_gl *context_gl,
|
||
|
const struct wined3d_gl_info *gl_info, unsigned int unit);
|
||
|
void wined3d_context_gl_alloc_fence(struct wined3d_context_gl *context_gl, struct wined3d_fence *fence);
|
||
|
void wined3d_context_gl_alloc_occlusion_query(struct wined3d_context_gl *context_gl,
|
||
|
struct wined3d_occlusion_query *query);
|
||
|
void wined3d_context_gl_alloc_pipeline_statistics_query(struct wined3d_context_gl *context_gl,
|
||
|
struct wined3d_pipeline_statistics_query *query);
|
||
|
void wined3d_context_gl_alloc_so_statistics_query(struct wined3d_context_gl *context_gl,
|
||
|
struct wined3d_so_statistics_query *query);
|
||
|
void wined3d_context_gl_alloc_timestamp_query(struct wined3d_context_gl *context_gl,
|
||
|
struct wined3d_timestamp_query *query);
|
||
|
GLuint wined3d_context_gl_allocate_vram_chunk_buffer(struct wined3d_context_gl *context_gl,
|
||
|
unsigned int pool, size_t size);
|
||
|
void wined3d_context_gl_apply_blit_state(struct wined3d_context_gl *context_gl, const struct wined3d_device *device);
|
||
|
BOOL wined3d_context_gl_apply_clear_state(struct wined3d_context_gl *context_gl, const struct wined3d_state *state,
|
||
|
unsigned int rt_count, const struct wined3d_fb_state *fb);
|
||
|
void wined3d_context_gl_apply_fbo_state_explicit(struct wined3d_context_gl *context_gl, GLenum target,
|
||
|
struct wined3d_resource *rt, unsigned int rt_sub_resource_idx,
|
||
|
struct wined3d_resource *ds, unsigned int ds_sub_resource_idx, uint32_t location);
|
||
|
void wined3d_context_gl_apply_ffp_blit_state(struct wined3d_context_gl *context_gl,
|
||
|
const struct wined3d_device *device);
|
||
|
void wined3d_context_gl_bind_bo(struct wined3d_context_gl *context_gl, GLenum binding, GLuint name);
|
||
|
void wined3d_context_gl_bind_dummy_textures(const struct wined3d_context_gl *context_gl);
|
||
|
void wined3d_context_gl_bind_texture(struct wined3d_context_gl *context_gl, GLenum target, GLuint name);
|
||
|
void wined3d_context_gl_check_fbo_status(const struct wined3d_context_gl *context_gl, GLenum target);
|
||
|
void wined3d_context_gl_copy_bo_address(struct wined3d_context_gl *context_gl,
|
||
|
const struct wined3d_bo_address *dst, const struct wined3d_bo_address *src,
|
||
|
unsigned int range_count, const struct wined3d_range *ranges, uint32_t map_flags);
|
||
|
void wined3d_context_gl_destroy(struct wined3d_context_gl *context_gl);
|
||
|
void wined3d_context_gl_destroy_bo(struct wined3d_context_gl *context_gl, struct wined3d_bo_gl *bo);
|
||
|
void wined3d_context_gl_draw_shaded_quad(struct wined3d_context_gl *context_gl, struct wined3d_texture_gl *texture_gl,
|
||
|
unsigned int sub_resource_idx, const RECT *src_rect, const RECT *dst_rect,
|
||
|
enum wined3d_texture_filter_type filter);
|
||
|
void wined3d_context_gl_draw_textured_quad(struct wined3d_context_gl *context_gl,
|
||
|
struct wined3d_texture_gl *texture_gl, unsigned int sub_resource_idx,
|
||
|
const RECT *src_rect, const RECT *dst_rect, enum wined3d_texture_filter_type filter);
|
||
|
void wined3d_context_gl_enable_clip_distances(struct wined3d_context_gl *context_gl, uint32_t mask);
|
||
|
void wined3d_context_gl_end_transform_feedback(struct wined3d_context_gl *context_gl);
|
||
|
void wined3d_context_gl_flush_bo_address(struct wined3d_context_gl *context_gl,
|
||
|
const struct wined3d_const_bo_address *data, size_t size);
|
||
|
void wined3d_context_gl_free_fence(struct wined3d_fence *fence);
|
||
|
void wined3d_context_gl_free_occlusion_query(struct wined3d_occlusion_query *query);
|
||
|
void wined3d_context_gl_free_pipeline_statistics_query(struct wined3d_pipeline_statistics_query *query);
|
||
|
void wined3d_context_gl_free_so_statistics_query(struct wined3d_so_statistics_query *query);
|
||
|
void wined3d_context_gl_free_timestamp_query(struct wined3d_timestamp_query *query);
|
||
|
struct wined3d_context_gl *wined3d_context_gl_get_current(void);
|
||
|
GLenum wined3d_context_gl_get_offscreen_gl_buffer(const struct wined3d_context_gl *context_gl);
|
||
|
const unsigned int *wined3d_context_gl_get_tex_unit_mapping(const struct wined3d_context_gl *context_gl,
|
||
|
const struct wined3d_shader_version *shader_version, unsigned int *base, unsigned int *count);
|
||
|
HRESULT wined3d_context_gl_init(struct wined3d_context_gl *context_gl, struct wined3d_swapchain_gl *swapchain_gl);
|
||
|
void wined3d_context_gl_load_tex_coords(const struct wined3d_context_gl *context_gl,
|
||
|
const struct wined3d_stream_info *si, GLuint *current_bo, const struct wined3d_state *state);
|
||
|
void *wined3d_context_gl_map_bo_address(struct wined3d_context_gl *context_gl,
|
||
|
const struct wined3d_bo_address *data, size_t size, uint32_t flags);
|
||
|
struct wined3d_context_gl *wined3d_context_gl_reacquire(struct wined3d_context_gl *context_gl);
|
||
|
void wined3d_context_gl_release(struct wined3d_context_gl *context_gl);
|
||
|
BOOL wined3d_context_gl_set_current(struct wined3d_context_gl *context_gl);
|
||
|
void wined3d_context_gl_submit_command_fence(struct wined3d_context_gl *context_gl);
|
||
|
void wined3d_context_gl_texture_update(struct wined3d_context_gl *context_gl,
|
||
|
const struct wined3d_texture_gl *texture_gl);
|
||
|
void wined3d_context_gl_unload_tex_coords(const struct wined3d_context_gl *context_gl);
|
||
|
void wined3d_context_gl_unmap_bo_address(struct wined3d_context_gl *context_gl, const struct wined3d_bo_address *data,
|
||
|
unsigned int range_count, const struct wined3d_range *ranges);
|
||
|
void wined3d_context_gl_update_stream_sources(struct wined3d_context_gl *context_gl, const struct wined3d_state *state);
|
||
|
void wined3d_context_gl_wait_command_fence(struct wined3d_context_gl *context_gl, uint64_t id);
|
||
|
|
||
|
void wined3d_arbfp_blitter_create(struct wined3d_blitter **next, const struct wined3d_device *device);
|
||
|
void wined3d_fbo_blitter_create(struct wined3d_blitter **next, const struct wined3d_gl_info *gl_info);
|
||
|
void wined3d_ffp_blitter_create(struct wined3d_blitter **next, const struct wined3d_gl_info *gl_info);
|
||
|
struct wined3d_blitter *wined3d_glsl_blitter_create(struct wined3d_blitter **next, const struct wined3d_device *device);
|
||
|
void wined3d_raw_blitter_create(struct wined3d_blitter **next, const struct wined3d_gl_info *gl_info);
|
||
|
|
||
|
struct wined3d_caps_gl_ctx
|
||
|
{
|
||
|
HDC dc;
|
||
|
HWND wnd;
|
||
|
HGLRC gl_ctx;
|
||
|
HDC restore_dc;
|
||
|
HGLRC restore_gl_ctx;
|
||
|
|
||
|
const struct wined3d_gl_info *gl_info;
|
||
|
GLuint test_vbo;
|
||
|
GLuint test_program_id;
|
||
|
|
||
|
const struct wined3d_gpu_description *gpu_description;
|
||
|
UINT64 vram_bytes;
|
||
|
};
|
||
|
|
||
|
BOOL wined3d_caps_gl_ctx_test_viewport_subpixel_bits(struct wined3d_caps_gl_ctx *ctx);
|
||
|
bool wined3d_caps_gl_ctx_test_filling_convention(struct wined3d_caps_gl_ctx *ctx, float offset);
|
||
|
|
||
|
struct wined3d_adapter_gl
|
||
|
{
|
||
|
struct wined3d_adapter a;
|
||
|
|
||
|
struct wined3d_gl_info gl_info;
|
||
|
|
||
|
struct wined3d_pixel_format *pixel_formats;
|
||
|
unsigned int pixel_format_count;
|
||
|
};
|
||
|
|
||
|
static inline struct wined3d_adapter_gl *wined3d_adapter_gl(struct wined3d_adapter *adapter)
|
||
|
{
|
||
|
return CONTAINING_RECORD(adapter, struct wined3d_adapter_gl, a);
|
||
|
}
|
||
|
|
||
|
static inline const struct wined3d_adapter_gl *wined3d_adapter_gl_const(const struct wined3d_adapter *adapter)
|
||
|
{
|
||
|
return CONTAINING_RECORD(adapter, struct wined3d_adapter_gl, a);
|
||
|
}
|
||
|
|
||
|
BOOL wined3d_adapter_gl_init_format_info(struct wined3d_adapter *adapter, struct wined3d_caps_gl_ctx *ctx);
|
||
|
|
||
|
struct wined3d_allocator_chunk_gl
|
||
|
{
|
||
|
struct wined3d_allocator_chunk c;
|
||
|
unsigned int memory_type;
|
||
|
GLuint gl_buffer;
|
||
|
};
|
||
|
|
||
|
static inline struct wined3d_allocator_chunk_gl *wined3d_allocator_chunk_gl(struct wined3d_allocator_chunk *chunk)
|
||
|
{
|
||
|
return CONTAINING_RECORD(chunk, struct wined3d_allocator_chunk_gl, c);
|
||
|
}
|
||
|
|
||
|
struct wined3d_dummy_textures
|
||
|
{
|
||
|
GLuint tex_1d;
|
||
|
GLuint tex_2d;
|
||
|
GLuint tex_rect;
|
||
|
GLuint tex_3d;
|
||
|
GLuint tex_cube;
|
||
|
GLuint tex_cube_array;
|
||
|
GLuint tex_1d_array;
|
||
|
GLuint tex_2d_array;
|
||
|
GLuint tex_buffer;
|
||
|
GLuint tex_2d_ms;
|
||
|
GLuint tex_2d_ms_array;
|
||
|
};
|
||
|
|
||
|
struct wined3d_device_gl
|
||
|
{
|
||
|
struct wined3d_device d;
|
||
|
|
||
|
/* Textures for when no other textures are bound. */
|
||
|
struct wined3d_dummy_textures dummy_textures;
|
||
|
|
||
|
CRITICAL_SECTION allocator_cs;
|
||
|
struct wined3d_allocator allocator;
|
||
|
uint64_t completed_fence_id;
|
||
|
uint64_t current_fence_id;
|
||
|
uint64_t retired_bo_size;
|
||
|
|
||
|
struct wined3d_retired_block_gl
|
||
|
{
|
||
|
struct wined3d_allocator_block *block;
|
||
|
uint64_t fence_id;
|
||
|
} *retired_blocks;
|
||
|
SIZE_T retired_blocks_size;
|
||
|
SIZE_T retired_block_count;
|
||
|
|
||
|
HWND backup_wnd;
|
||
|
HDC backup_dc;
|
||
|
};
|
||
|
|
||
|
static inline struct wined3d_device_gl *wined3d_device_gl(struct wined3d_device *device)
|
||
|
{
|
||
|
return CONTAINING_RECORD(device, struct wined3d_device_gl, d);
|
||
|
}
|
||
|
|
||
|
static inline struct wined3d_device_gl *wined3d_device_gl_from_allocator(struct wined3d_allocator *allocator)
|
||
|
{
|
||
|
return CONTAINING_RECORD(allocator, struct wined3d_device_gl, allocator);
|
||
|
}
|
||
|
|
||
|
static inline void wined3d_device_gl_allocator_lock(struct wined3d_device_gl *device_gl)
|
||
|
{
|
||
|
EnterCriticalSection(&device_gl->allocator_cs);
|
||
|
}
|
||
|
|
||
|
static inline void wined3d_device_gl_allocator_unlock(struct wined3d_device_gl *device_gl)
|
||
|
{
|
||
|
LeaveCriticalSection(&device_gl->allocator_cs);
|
||
|
}
|
||
|
|
||
|
static inline void wined3d_allocator_chunk_gl_lock(struct wined3d_allocator_chunk_gl *chunk_gl)
|
||
|
{
|
||
|
wined3d_device_gl_allocator_lock(wined3d_device_gl_from_allocator(chunk_gl->c.allocator));
|
||
|
}
|
||
|
|
||
|
static inline void wined3d_allocator_chunk_gl_unlock(struct wined3d_allocator_chunk_gl *chunk_gl)
|
||
|
{
|
||
|
wined3d_device_gl_allocator_unlock(wined3d_device_gl_from_allocator(chunk_gl->c.allocator));
|
||
|
}
|
||
|
|
||
|
bool wined3d_device_gl_create_bo(struct wined3d_device_gl *device_gl,
|
||
|
struct wined3d_context_gl *context_gl, GLsizeiptr size, GLenum binding,
|
||
|
GLenum usage, bool coherent, GLbitfield flags, struct wined3d_bo_gl *bo);
|
||
|
void wined3d_device_gl_create_primary_opengl_context_cs(void *object);
|
||
|
void wined3d_device_gl_delete_opengl_contexts_cs(void *object);
|
||
|
HDC wined3d_device_gl_get_backup_dc(struct wined3d_device_gl *device_gl);
|
||
|
GLbitfield wined3d_device_gl_get_memory_type_flags(unsigned int memory_type_idx);
|
||
|
|
||
|
GLbitfield wined3d_resource_gl_map_flags(const struct wined3d_bo_gl *bo, DWORD d3d_flags);
|
||
|
GLenum wined3d_resource_gl_legacy_map_flags(DWORD d3d_flags);
|
||
|
GLbitfield wined3d_resource_gl_storage_flags(const struct wined3d_resource *resource);
|
||
|
|
||
|
static inline void wined3d_context_gl_reference_bo(struct wined3d_context_gl *context_gl, struct wined3d_bo_gl *bo_gl)
|
||
|
{
|
||
|
struct wined3d_device_gl *device_gl = wined3d_device_gl(context_gl->c.device);
|
||
|
|
||
|
bo_gl->command_fence_id = device_gl->current_fence_id;
|
||
|
}
|
||
|
|
||
|
static inline void wined3d_context_gl_reference_buffer(struct wined3d_context_gl *context_gl,
|
||
|
struct wined3d_buffer *buffer)
|
||
|
{
|
||
|
if (buffer->buffer_object)
|
||
|
wined3d_context_gl_reference_bo(context_gl, wined3d_bo_gl(buffer->buffer_object));
|
||
|
}
|
||
|
|
||
|
struct gl_texture
|
||
|
{
|
||
|
struct wined3d_sampler_desc sampler_desc;
|
||
|
GLuint name;
|
||
|
};
|
||
|
|
||
|
struct wined3d_renderbuffer_entry
|
||
|
{
|
||
|
struct list entry;
|
||
|
GLuint id;
|
||
|
unsigned int width, height;
|
||
|
};
|
||
|
|
||
|
struct wined3d_texture_gl
|
||
|
{
|
||
|
struct wined3d_texture t;
|
||
|
|
||
|
struct gl_texture texture_rgb, texture_srgb;
|
||
|
|
||
|
GLenum target;
|
||
|
|
||
|
GLuint rb_multisample;
|
||
|
GLuint rb_resolved;
|
||
|
|
||
|
struct list renderbuffers;
|
||
|
const struct wined3d_renderbuffer_entry *current_renderbuffer;
|
||
|
};
|
||
|
|
||
|
static inline struct wined3d_texture_gl *wined3d_texture_gl(struct wined3d_texture *texture)
|
||
|
{
|
||
|
return CONTAINING_RECORD(texture, struct wined3d_texture_gl, t);
|
||
|
}
|
||
|
|
||
|
static inline struct gl_texture *wined3d_texture_gl_get_gl_texture(struct wined3d_texture_gl *texture_gl, bool srgb)
|
||
|
{
|
||
|
return srgb ? &texture_gl->texture_srgb : &texture_gl->texture_rgb;
|
||
|
}
|
||
|
|
||
|
static inline GLenum wined3d_texture_gl_get_sub_resource_target(const struct wined3d_texture_gl *texture_gl,
|
||
|
unsigned int sub_resource_idx)
|
||
|
{
|
||
|
static const GLenum cube_targets[] =
|
||
|
{
|
||
|
GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB,
|
||
|
GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB,
|
||
|
GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB,
|
||
|
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB,
|
||
|
GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB,
|
||
|
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB,
|
||
|
};
|
||
|
|
||
|
if (texture_gl->t.resource.usage & WINED3DUSAGE_LEGACY_CUBEMAP)
|
||
|
return cube_targets[sub_resource_idx / texture_gl->t.level_count];
|
||
|
return texture_gl->target;
|
||
|
}
|
||
|
|
||
|
static inline GLuint wined3d_texture_gl_get_texture_name(const struct wined3d_texture_gl *texture_gl,
|
||
|
const struct wined3d_context *context, bool srgb)
|
||
|
{
|
||
|
if (srgb && needs_separate_srgb_gl_texture(context, &texture_gl->t))
|
||
|
return texture_gl->texture_srgb.name;
|
||
|
return texture_gl->texture_rgb.name;
|
||
|
}
|
||
|
|
||
|
static inline bool wined3d_texture_gl_is_multisample_location(const struct wined3d_texture_gl *texture_gl,
|
||
|
uint32_t location)
|
||
|
{
|
||
|
if (location == WINED3D_LOCATION_RB_MULTISAMPLE)
|
||
|
return true;
|
||
|
if (location != WINED3D_LOCATION_TEXTURE_RGB && location != WINED3D_LOCATION_TEXTURE_SRGB)
|
||
|
return false;
|
||
|
return texture_gl->target == GL_TEXTURE_2D_MULTISAMPLE || texture_gl->target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY;
|
||
|
}
|
||
|
|
||
|
struct wined3d_blt_info
|
||
|
{
|
||
|
GLenum bind_target;
|
||
|
struct wined3d_vec3 texcoords[4];
|
||
|
};
|
||
|
|
||
|
void texture2d_get_blt_info(const struct wined3d_texture_gl *texture_gl, unsigned int sub_resource_idx,
|
||
|
const RECT *rect, struct wined3d_blt_info *info);
|
||
|
void texture2d_load_fb_texture(struct wined3d_texture_gl *texture_gl, unsigned int sub_resource_idx,
|
||
|
BOOL srgb, struct wined3d_context *context);
|
||
|
void texture2d_read_from_framebuffer(struct wined3d_texture *texture, unsigned int sub_resource_idx,
|
||
|
struct wined3d_context *context, DWORD src_location, DWORD dst_location);
|
||
|
|
||
|
void wined3d_gl_texture_swizzle_from_color_fixup(GLint swizzle[4], struct color_fixup_desc fixup);
|
||
|
GLenum wined3d_texture_get_gl_buffer(const struct wined3d_texture *texture);
|
||
|
|
||
|
void wined3d_texture_gl_apply_sampler_desc(struct wined3d_texture_gl *texture_gl,
|
||
|
const struct wined3d_sampler_desc *sampler_desc, const struct wined3d_context_gl *context_gl);
|
||
|
void wined3d_texture_gl_bind(struct wined3d_texture_gl *texture_gl, struct wined3d_context_gl *context_gl, BOOL srgb);
|
||
|
void wined3d_texture_gl_bind_and_dirtify(struct wined3d_texture_gl *texture_gl,
|
||
|
struct wined3d_context_gl *context_gl, BOOL srgb);
|
||
|
HRESULT wined3d_texture_gl_init(struct wined3d_texture_gl *texture_gl, struct wined3d_device *device,
|
||
|
const struct wined3d_resource_desc *desc, unsigned int layer_count, unsigned int level_count,
|
||
|
uint32_t flags, void *parent, const struct wined3d_parent_ops *parent_ops);
|
||
|
void wined3d_texture_gl_prepare_texture(struct wined3d_texture_gl *texture_gl,
|
||
|
struct wined3d_context_gl *context_gl, BOOL srgb);
|
||
|
void wined3d_texture_gl_set_compatible_renderbuffer(struct wined3d_texture_gl *texture_gl,
|
||
|
struct wined3d_context_gl *context_gl, unsigned int level, const struct wined3d_rendertarget_info *rt);
|
||
|
|
||
|
struct wined3d_sampler_gl
|
||
|
{
|
||
|
struct wined3d_sampler s;
|
||
|
|
||
|
GLuint name;
|
||
|
};
|
||
|
|
||
|
static inline struct wined3d_sampler_gl *wined3d_sampler_gl(struct wined3d_sampler *sampler)
|
||
|
{
|
||
|
return CONTAINING_RECORD(sampler, struct wined3d_sampler_gl, s);
|
||
|
}
|
||
|
|
||
|
void wined3d_sampler_gl_bind(struct wined3d_sampler_gl *sampler_gl, unsigned int unit,
|
||
|
struct wined3d_texture_gl *texture_gl, const struct wined3d_context_gl *context_gl);
|
||
|
void wined3d_sampler_gl_init(struct wined3d_sampler_gl *sampler_gl, struct wined3d_device *device,
|
||
|
const struct wined3d_sampler_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops);
|
||
|
|
||
|
struct wined3d_buffer_gl
|
||
|
{
|
||
|
struct wined3d_buffer b;
|
||
|
};
|
||
|
|
||
|
static inline struct wined3d_buffer_gl *wined3d_buffer_gl(struct wined3d_buffer *buffer)
|
||
|
{
|
||
|
return CONTAINING_RECORD(buffer, struct wined3d_buffer_gl, b);
|
||
|
}
|
||
|
|
||
|
static inline const struct wined3d_buffer_gl *wined3d_buffer_gl_const(const struct wined3d_buffer *buffer)
|
||
|
{
|
||
|
return CONTAINING_RECORD(buffer, struct wined3d_buffer_gl, b);
|
||
|
}
|
||
|
|
||
|
HRESULT wined3d_buffer_gl_init(struct wined3d_buffer_gl *buffer_gl, struct wined3d_device *device,
|
||
|
const struct wined3d_buffer_desc *desc, const struct wined3d_sub_resource_data *data,
|
||
|
void *parent, const struct wined3d_parent_ops *parent_ops);
|
||
|
|
||
|
struct wined3d_rendertarget_view_gl
|
||
|
{
|
||
|
struct wined3d_rendertarget_view v;
|
||
|
struct wined3d_gl_view gl_view;
|
||
|
};
|
||
|
|
||
|
static inline struct wined3d_rendertarget_view_gl *wined3d_rendertarget_view_gl(
|
||
|
struct wined3d_rendertarget_view *view)
|
||
|
{
|
||
|
return CONTAINING_RECORD(view, struct wined3d_rendertarget_view_gl, v);
|
||
|
}
|
||
|
|
||
|
HRESULT wined3d_rendertarget_view_gl_init(struct wined3d_rendertarget_view_gl *view_gl,
|
||
|
const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
|
||
|
void *parent, const struct wined3d_parent_ops *parent_ops);
|
||
|
|
||
|
struct wined3d_shader_resource_view_gl
|
||
|
{
|
||
|
struct wined3d_shader_resource_view v;
|
||
|
struct wined3d_bo_user bo_user;
|
||
|
struct wined3d_gl_view gl_view;
|
||
|
};
|
||
|
|
||
|
static inline struct wined3d_shader_resource_view_gl *wined3d_shader_resource_view_gl(
|
||
|
struct wined3d_shader_resource_view *view)
|
||
|
{
|
||
|
return CONTAINING_RECORD(view, struct wined3d_shader_resource_view_gl, v);
|
||
|
}
|
||
|
|
||
|
void wined3d_shader_resource_view_gl_bind(struct wined3d_shader_resource_view_gl *view_gl, unsigned int unit,
|
||
|
struct wined3d_sampler_gl *sampler_gl, struct wined3d_context_gl *context_gl);
|
||
|
void wined3d_shader_resource_view_gl_generate_mipmap(struct wined3d_shader_resource_view_gl *srv_gl,
|
||
|
struct wined3d_context_gl *context_gl);
|
||
|
HRESULT wined3d_shader_resource_view_gl_init(struct wined3d_shader_resource_view_gl *view_gl,
|
||
|
const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
|
||
|
void *parent, const struct wined3d_parent_ops *parent_ops);
|
||
|
void wined3d_shader_resource_view_gl_update(struct wined3d_shader_resource_view_gl *srv_gl,
|
||
|
struct wined3d_context_gl *context_gl);
|
||
|
|
||
|
struct wined3d_unordered_access_view_gl
|
||
|
{
|
||
|
struct wined3d_unordered_access_view v;
|
||
|
struct wined3d_bo_user bo_user;
|
||
|
struct wined3d_gl_view gl_view;
|
||
|
struct wined3d_bo_gl counter_bo;
|
||
|
};
|
||
|
|
||
|
static inline struct wined3d_unordered_access_view_gl *wined3d_unordered_access_view_gl(
|
||
|
struct wined3d_unordered_access_view *view)
|
||
|
{
|
||
|
return CONTAINING_RECORD(view, struct wined3d_unordered_access_view_gl, v);
|
||
|
}
|
||
|
|
||
|
void wined3d_unordered_access_view_gl_clear(struct wined3d_unordered_access_view_gl *view_gl,
|
||
|
const struct wined3d_uvec4 *clear_value, struct wined3d_context_gl *context_gl, bool fp);
|
||
|
HRESULT wined3d_unordered_access_view_gl_init(struct wined3d_unordered_access_view_gl *view_gl,
|
||
|
const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
|
||
|
void *parent, const struct wined3d_parent_ops *parent_ops);
|
||
|
void wined3d_unordered_access_view_gl_update(struct wined3d_unordered_access_view_gl *uav_gl,
|
||
|
struct wined3d_context_gl *context_gl);
|
||
|
|
||
|
struct wined3d_swapchain_gl
|
||
|
{
|
||
|
struct wined3d_swapchain s;
|
||
|
};
|
||
|
|
||
|
static inline struct wined3d_swapchain_gl *wined3d_swapchain_gl(struct wined3d_swapchain *swapchain)
|
||
|
{
|
||
|
return CONTAINING_RECORD(swapchain, struct wined3d_swapchain_gl, s);
|
||
|
}
|
||
|
|
||
|
void wined3d_swapchain_gl_cleanup(struct wined3d_swapchain_gl *swapchain_gl);
|
||
|
struct wined3d_context_gl *wined3d_swapchain_gl_get_context(struct wined3d_swapchain_gl *swapchain_gl);
|
||
|
HRESULT wined3d_swapchain_gl_init(struct wined3d_swapchain_gl *swapchain_gl, struct wined3d_device *device,
|
||
|
const struct wined3d_swapchain_desc *desc, struct wined3d_swapchain_state_parent *state_parent,
|
||
|
void *parent, const struct wined3d_parent_ops *parent_ops);
|
||
|
|
||
|
struct wined3d_format_gl
|
||
|
{
|
||
|
struct wined3d_format f;
|
||
|
|
||
|
GLenum vtx_type;
|
||
|
GLint vtx_format;
|
||
|
|
||
|
GLint internal;
|
||
|
GLint srgb_internal;
|
||
|
GLint rt_internal;
|
||
|
GLint format;
|
||
|
GLint type;
|
||
|
|
||
|
GLenum view_class;
|
||
|
};
|
||
|
|
||
|
static inline const struct wined3d_format_gl *wined3d_format_gl(const struct wined3d_format *format)
|
||
|
{
|
||
|
return CONTAINING_RECORD(format, struct wined3d_format_gl, f);
|
||
|
}
|
||
|
|
||
|
static inline GLuint wined3d_gl_get_internal_format(struct wined3d_resource *resource,
|
||
|
const struct wined3d_format_gl *format_gl, bool srgb)
|
||
|
{
|
||
|
if (srgb)
|
||
|
return format_gl->srgb_internal;
|
||
|
else if ((resource->bind_flags & WINED3D_BIND_RENDER_TARGET) && wined3d_resource_is_offscreen(resource))
|
||
|
return format_gl->rt_internal;
|
||
|
else
|
||
|
return format_gl->internal;
|
||
|
}
|
||
|
|
||
|
#endif /* __WINE_WINED3D_GL */
|