wined3d_private.h 163 KB
Newer Older
1 2 3 4 5
/*
 * Direct3D wine internal private include file
 *
 * Copyright 2002-2003 The wine-d3d team
 * Copyright 2002-2003 Raphael Junqueira
6
 * Copyright 2002-2003, 2004 Jason Edmeades
Oliver Stieber's avatar
Oliver Stieber committed
7
 * Copyright 2005 Oliver Stieber
8
 * Copyright 2006-2011, 2013 Stefan Dösinger for CodeWeavers
9 10 11 12 13 14 15 16 17 18 19 20 21
 *
 * 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
22
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 24 25 26 27
 */

#ifndef __WINE_WINED3D_PRIVATE_H
#define __WINE_WINED3D_PRIVATE_H

28 29 30 31 32 33
#ifdef USE_WIN32_OPENGL
#define WINE_GLAPI __stdcall
#else
#define WINE_GLAPI
#endif

34
#include <assert.h>
35
#include <stdarg.h>
36
#include <math.h>
37
#include <limits.h>
38 39
#include "ntstatus.h"
#define WIN32_NO_STATUS
40 41
#define NONAMELESSUNION
#define NONAMELESSSTRUCT
42
#define COBJMACROS
43 44
#include "windef.h"
#include "winbase.h"
45
#include "winreg.h"
46 47
#include "wingdi.h"
#include "winuser.h"
48 49
#include "winternl.h"
#include "ddk/d3dkmthk.h"
50
#include "wine/debug.h"
51
#include "wine/heap.h"
52
#include "wine/unicode.h"
53

54 55
#include "objbase.h"
#include "wine/wined3d.h"
56
#include "wined3d_gl.h"
57
#include "wine/list.h"
58
#include "wine/rbtree.h"
59
#include "wine/wgl_driver.h"
60

61 62
#define MAKEDWORD_VERSION(maj, min) (((maj & 0xffffu) << 16) | (min & 0xffffu))

63 64 65 66
/* Driver quirks */
#define WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT       0x00000001
#define WINED3D_QUIRK_SET_TEXCOORD_W            0x00000002
#define WINED3D_QUIRK_GLSL_CLIP_VARYING         0x00000004
67
#define WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA     0x00000008
68
#define WINED3D_QUIRK_NV_CLIP_BROKEN            0x00000010
69
#define WINED3D_QUIRK_FBO_TEX_UPDATE            0x00000020
70
#define WINED3D_QUIRK_BROKEN_RGBA16             0x00000040
71
#define WINED3D_QUIRK_INFO_LOG_SPAM             0x00000080
72
#define WINED3D_QUIRK_LIMITED_TEX_FILTERING     0x00000100
73
#define WINED3D_QUIRK_BROKEN_ARB_FOG            0x00000200
74

75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
enum wined3d_ffp_idx
{
    WINED3D_FFP_POSITION = 0,
    WINED3D_FFP_BLENDWEIGHT = 1,
    WINED3D_FFP_BLENDINDICES = 2,
    WINED3D_FFP_NORMAL = 3,
    WINED3D_FFP_PSIZE = 4,
    WINED3D_FFP_DIFFUSE = 5,
    WINED3D_FFP_SPECULAR = 6,
    WINED3D_FFP_TEXCOORD0 = 7,
    WINED3D_FFP_TEXCOORD1 = 8,
    WINED3D_FFP_TEXCOORD2 = 9,
    WINED3D_FFP_TEXCOORD3 = 10,
    WINED3D_FFP_TEXCOORD4 = 11,
    WINED3D_FFP_TEXCOORD5 = 12,
    WINED3D_FFP_TEXCOORD6 = 13,
    WINED3D_FFP_TEXCOORD7 = 14,
    WINED3D_FFP_ATTRIBS_COUNT = 15,
};

enum wined3d_ffp_emit_idx
{
    WINED3D_FFP_EMIT_FLOAT1,
    WINED3D_FFP_EMIT_FLOAT2,
    WINED3D_FFP_EMIT_FLOAT3,
    WINED3D_FFP_EMIT_FLOAT4,
    WINED3D_FFP_EMIT_D3DCOLOR,
    WINED3D_FFP_EMIT_UBYTE4,
    WINED3D_FFP_EMIT_SHORT2,
    WINED3D_FFP_EMIT_SHORT4,
    WINED3D_FFP_EMIT_UBYTE4N,
    WINED3D_FFP_EMIT_SHORT2N,
    WINED3D_FFP_EMIT_SHORT4N,
    WINED3D_FFP_EMIT_USHORT2N,
    WINED3D_FFP_EMIT_USHORT4N,
    WINED3D_FFP_EMIT_UDEC3,
    WINED3D_FFP_EMIT_DEC3N,
    WINED3D_FFP_EMIT_FLOAT16_2,
    WINED3D_FFP_EMIT_FLOAT16_4,
    WINED3D_FFP_EMIT_INVALID,
    WINED3D_FFP_EMIT_COUNT,
};

118 119 120 121 122 123 124 125 126 127
/* Texture format fixups */

enum fixup_channel_source
{
    CHANNEL_SOURCE_ZERO = 0,
    CHANNEL_SOURCE_ONE = 1,
    CHANNEL_SOURCE_X = 2,
    CHANNEL_SOURCE_Y = 3,
    CHANNEL_SOURCE_Z = 4,
    CHANNEL_SOURCE_W = 5,
128 129
    CHANNEL_SOURCE_COMPLEX0 = 6,
    CHANNEL_SOURCE_COMPLEX1 = 7,
130 131
};

132
enum complex_fixup
133
{
134 135 136 137 138
    COMPLEX_FIXUP_NONE = 0,
    COMPLEX_FIXUP_YUY2 = 1,
    COMPLEX_FIXUP_UYVY = 2,
    COMPLEX_FIXUP_YV12 = 3,
    COMPLEX_FIXUP_P8   = 4,
139
    COMPLEX_FIXUP_NV12 = 5,
140 141 142 143 144
};

#include <pshpack2.h>
struct color_fixup_desc
{
145 146 147 148 149 150 151 152
    unsigned short x_sign_fixup : 1;
    unsigned short x_source : 3;
    unsigned short y_sign_fixup : 1;
    unsigned short y_source : 3;
    unsigned short z_sign_fixup : 1;
    unsigned short z_source : 3;
    unsigned short w_sign_fixup : 1;
    unsigned short w_source : 3;
153 154 155
};
#include <poppack.h>

156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
struct wined3d_d3d_limits
{
    unsigned int vs_version, hs_version, ds_version, gs_version, ps_version, cs_version;
    DWORD vs_uniform_count;
    DWORD ps_uniform_count;
    unsigned int varying_count;
    unsigned int ffp_textures;
    unsigned int ffp_blend_stages;
    unsigned int ffp_vertex_blend_matrices;
    unsigned int active_light_count;
};

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);
extern wined3d_ffp_attrib_func specular_func_3ubv DECLSPEC_HIDDEN;

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_d3d_info
{
    struct wined3d_d3d_limits limits;
    struct wined3d_ffp_attrib_ops ffp_attrib_ops;
    BOOL xyzrhw;
    BOOL emulated_flatshading;
    BOOL ffp_generic_attributes;
    BOOL vs_clipping;
    BOOL shader_color_key;
    DWORD valid_rt_mask;
    DWORD wined3d_creation_flags;
    BOOL shader_double_precision;
195
    enum wined3d_feature_level feature_level;
196 197
};

198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
static const struct color_fixup_desc COLOR_FIXUP_IDENTITY =
        {0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_W};

static inline struct color_fixup_desc create_color_fixup_desc(
        int sign0, enum fixup_channel_source src0, int sign1, enum fixup_channel_source src1,
        int sign2, enum fixup_channel_source src2, int sign3, enum fixup_channel_source src3)
{
    struct color_fixup_desc fixup =
    {
        sign0, src0,
        sign1, src1,
        sign2, src2,
        sign3, src3,
    };
    return fixup;
}

215
static inline struct color_fixup_desc create_complex_fixup_desc(enum complex_fixup complex_fixup)
216 217 218
{
    struct color_fixup_desc fixup =
    {
219 220 221 222
        0u, complex_fixup & (1u << 0) ? CHANNEL_SOURCE_COMPLEX1 : CHANNEL_SOURCE_COMPLEX0,
        0u, complex_fixup & (1u << 1) ? CHANNEL_SOURCE_COMPLEX1 : CHANNEL_SOURCE_COMPLEX0,
        0u, complex_fixup & (1u << 2) ? CHANNEL_SOURCE_COMPLEX1 : CHANNEL_SOURCE_COMPLEX0,
        0u, complex_fixup & (1u << 3) ? CHANNEL_SOURCE_COMPLEX1 : CHANNEL_SOURCE_COMPLEX0,
223 224 225 226 227 228 229 230 231
    };
    return fixup;
}

static inline BOOL is_identity_fixup(struct color_fixup_desc fixup)
{
    return !memcmp(&fixup, &COLOR_FIXUP_IDENTITY, sizeof(fixup));
}

232
static inline BOOL is_complex_fixup(struct color_fixup_desc fixup)
233
{
234
    return fixup.x_source == CHANNEL_SOURCE_COMPLEX0 || fixup.x_source == CHANNEL_SOURCE_COMPLEX1;
235 236
}

237 238 239 240 241
static inline BOOL is_scaling_fixup(struct color_fixup_desc fixup)
{
    return fixup.x_sign_fixup || fixup.y_sign_fixup || fixup.z_sign_fixup || fixup.w_sign_fixup;
}

242 243 244 245 246 247 248 249
static inline BOOL is_same_fixup(struct color_fixup_desc f1, struct color_fixup_desc f2)
{
    return f1.x_sign_fixup == f2.x_sign_fixup && f1.x_source == f2.x_source
            && f1.y_sign_fixup == f2.y_sign_fixup && f1.y_source == f2.y_source
            && f1.z_sign_fixup == f2.z_sign_fixup && f1.z_source == f2.z_source
            && f1.w_sign_fixup == f2.w_sign_fixup && f1.w_source == f2.w_source;
}

250
static inline enum complex_fixup get_complex_fixup(struct color_fixup_desc fixup)
251
{
252
    enum complex_fixup complex_fixup = 0;
253 254 255 256
    if (fixup.x_source == CHANNEL_SOURCE_COMPLEX1) complex_fixup |= (1u << 0);
    if (fixup.y_source == CHANNEL_SOURCE_COMPLEX1) complex_fixup |= (1u << 1);
    if (fixup.z_source == CHANNEL_SOURCE_COMPLEX1) complex_fixup |= (1u << 2);
    if (fixup.w_source == CHANNEL_SOURCE_COMPLEX1) complex_fixup |= (1u << 3);
257
    return complex_fixup;
258 259
}

260
/* Device caps */
261 262 263 264 265 266
#define MAX_STREAMS                 16
#define MAX_TEXTURES                8
#define MAX_FRAGMENT_SAMPLERS       16
#define MAX_VERTEX_SAMPLERS         4
#define MAX_COMBINED_SAMPLERS       (MAX_FRAGMENT_SAMPLERS + MAX_VERTEX_SAMPLERS)
#define MAX_ACTIVE_LIGHTS           8
267
#define MAX_CLIP_DISTANCES          8
268 269 270
#define MAX_CONSTANT_BUFFERS        15
#define MAX_SAMPLER_OBJECTS         16
#define MAX_SHADER_RESOURCE_VIEWS   128
271
#define MAX_RENDER_TARGET_VIEWS     8
272
#define MAX_UNORDERED_ACCESS_VIEWS  8
273
#define MAX_TGSM_REGISTERS          8192
274
#define MAX_VERTEX_BLENDS           4
275

276 277
struct min_lookup
{
278
    GLenum mip[WINED3D_TEXF_LINEAR + 1];
279 280
};

281 282
extern const struct min_lookup minMipLookup[WINED3D_TEXF_LINEAR + 1] DECLSPEC_HIDDEN;
extern const GLenum magLookup[WINED3D_TEXF_LINEAR + 1] DECLSPEC_HIDDEN;
283

284 285
GLenum wined3d_gl_compare_func(enum wined3d_cmp_func f) DECLSPEC_HIDDEN;

286 287 288 289 290 291 292
static inline enum wined3d_cmp_func wined3d_sanitize_cmp_func(enum wined3d_cmp_func func)
{
    if (func < WINED3D_CMP_NEVER || func > WINED3D_CMP_ALWAYS)
        return WINED3D_CMP_ALWAYS;
    return func;
}

293
static inline GLenum wined3d_gl_mag_filter(enum wined3d_texture_filter_type mag_filter)
294
{
295
    return magLookup[mag_filter];
296 297
}

298 299
static inline GLenum wined3d_gl_min_mip_filter(enum wined3d_texture_filter_type min_filter,
        enum wined3d_texture_filter_type mip_filter)
300
{
301
    return minMipLookup[min_filter].mip[mip_filter];
302 303
}

304 305
/* float_16_to_32() and float_32_to_16() (see implementation in
 * surface_base.c) convert 16 bit floats in the FLOAT16 data type
306 307
 * to standard C floats and vice versa. They do not depend on the encoding
 * of the C float, so they are platform independent, but slow. On x86 and
Austin English's avatar
Austin English committed
308 309 310
 * other IEEE 754 compliant platforms the conversion can be accelerated by
 * bit shifting the exponent and mantissa. There are also some SSE-based
 * assembly routines out there.
311 312 313
 *
 * See GL_NV_half_float for a reference of the FLOAT16 / GL_HALF format
 */
314 315
static inline float float_16_to_32(const unsigned short *in)
{
316 317 318
    const unsigned short s = ((*in) & 0x8000u);
    const unsigned short e = ((*in) & 0x7c00u) >> 10;
    const unsigned short m = (*in) & 0x3ffu;
319
    const float sgn = (s ? -1.0f : 1.0f);
320 321

    if(e == 0) {
322
        if(m == 0) return sgn * 0.0f; /* +0.0 or -0.0 */
323
        else return sgn * powf(2, -14.0f) * ((float)m / 1024.0f);
324
    } else if(e < 31) {
325
        return sgn * powf(2, (float)e - 15.0f) * (1.0f + ((float)m / 1024.0f));
326
    } else {
Thomas Faber's avatar
Thomas Faber committed
327
        if(m == 0) return sgn * INFINITY;
Henri Verbeet's avatar
Henri Verbeet committed
328
        else return NAN;
329 330 331
    }
}

332 333
static inline float float_24_to_32(DWORD in)
{
334 335 336
    const float sgn = in & 0x800000u ? -1.0f : 1.0f;
    const unsigned short e = (in & 0x780000u) >> 19;
    const unsigned int m = in & 0x7ffffu;
337 338 339 340

    if (e == 0)
    {
        if (m == 0) return sgn * 0.0f; /* +0.0 or -0.0 */
341
        else return sgn * powf(2, -6.0f) * ((float)m / 524288.0f);
342 343 344
    }
    else if (e < 15)
    {
345
        return sgn * powf(2, (float)e - 7.0f) * (1.0f + ((float)m / 524288.0f));
346 347 348
    }
    else
    {
Thomas Faber's avatar
Thomas Faber committed
349
        if (m == 0) return sgn * INFINITY;
Henri Verbeet's avatar
Henri Verbeet committed
350
        else return NAN;
351 352 353
    }
}

354 355 356 357 358 359 360 361 362 363 364
static inline unsigned int wined3d_popcount(unsigned int x)
{
#ifdef HAVE___BUILTIN_POPCOUNT
    return __builtin_popcount(x);
#else
    x -= x >> 1 & 0x55555555;
    x = (x & 0x33333333) + (x >> 2 & 0x33333333);
    return ((x + (x >> 4)) & 0x0f0f0f0f) * 0x01010101 >> 24;
#endif
}

365 366 367 368 369 370 371
static inline void wined3d_pause(void)
{
#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
    __asm__ __volatile__( "rep;nop" : : : "memory" );
#endif
}

372
#define ORM_BACKBUFFER  0
373
#define ORM_FBO         1
374

375
#define PCI_VENDOR_NONE 0xffff /* e.g. 0x8086 for Intel and 0x10de for Nvidia */
376 377
#define PCI_DEVICE_NONE 0xffff /* e.g. 0x14f for a Geforce6200 */

378 379
/* NOTE: When adding fields to this structure, make sure to update the default
 * values in wined3d_main.c as well. */
380 381
struct wined3d_settings
{
382
    unsigned int cs_multithreaded;
383
    BOOL explicit_gl_version;
384
    DWORD max_gl_version;
385
    BOOL use_glsl;
386 387 388 389
    int offscreen_rendering_mode;
    unsigned short pci_vendor_id;
    unsigned short pci_device_id;
    /* Memory tracking and object counting. */
390
    UINT64 emulated_textureram;
391
    char *logo;
392
    unsigned int multisample_textures;
393
    unsigned int sample_count;
394
    BOOL check_float_constants;
395
    unsigned int max_sm_vs;
396
    unsigned int max_sm_hs;
397
    unsigned int max_sm_ds;
398 399
    unsigned int max_sm_gs;
    unsigned int max_sm_ps;
400
    unsigned int max_sm_cs;
401
    BOOL no_3d;
402 403 404
};

extern struct wined3d_settings wined3d_settings DECLSPEC_HIDDEN;
405

406
enum wined3d_shader_resource_type
407
{
408
    WINED3D_SHADER_RESOURCE_NONE,
409
    WINED3D_SHADER_RESOURCE_BUFFER,
410 411
    WINED3D_SHADER_RESOURCE_TEXTURE_1D,
    WINED3D_SHADER_RESOURCE_TEXTURE_2D,
412
    WINED3D_SHADER_RESOURCE_TEXTURE_2DMS,
413 414
    WINED3D_SHADER_RESOURCE_TEXTURE_3D,
    WINED3D_SHADER_RESOURCE_TEXTURE_CUBE,
415 416 417
    WINED3D_SHADER_RESOURCE_TEXTURE_1DARRAY,
    WINED3D_SHADER_RESOURCE_TEXTURE_2DARRAY,
    WINED3D_SHADER_RESOURCE_TEXTURE_2DMSARRAY,
418
    WINED3D_SHADER_RESOURCE_TEXTURE_CUBEARRAY,
419
};
420

421 422 423
#define WINED3D_SHADER_CONST_VS_F            0x00000001
#define WINED3D_SHADER_CONST_VS_I            0x00000002
#define WINED3D_SHADER_CONST_VS_B            0x00000004
424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
#define WINED3D_SHADER_CONST_VS_CLIP_PLANES  0x00000008
#define WINED3D_SHADER_CONST_VS_POINTSIZE    0x00000010
#define WINED3D_SHADER_CONST_POS_FIXUP       0x00000020
#define WINED3D_SHADER_CONST_PS_F            0x00000040
#define WINED3D_SHADER_CONST_PS_I            0x00000080
#define WINED3D_SHADER_CONST_PS_B            0x00000100
#define WINED3D_SHADER_CONST_PS_BUMP_ENV     0x00000200
#define WINED3D_SHADER_CONST_PS_FOG          0x00000400
#define WINED3D_SHADER_CONST_PS_ALPHA_TEST   0x00000800
#define WINED3D_SHADER_CONST_PS_Y_CORR       0x00001000
#define WINED3D_SHADER_CONST_PS_NP2_FIXUP    0x00002000
#define WINED3D_SHADER_CONST_FFP_MODELVIEW   0x00004000
#define WINED3D_SHADER_CONST_FFP_VERTEXBLEND 0x00008000
#define WINED3D_SHADER_CONST_FFP_PROJ        0x00010000
#define WINED3D_SHADER_CONST_FFP_TEXMATRIX   0x00020000
#define WINED3D_SHADER_CONST_FFP_MATERIAL    0x00040000
#define WINED3D_SHADER_CONST_FFP_LIGHTS      0x00080000
#define WINED3D_SHADER_CONST_FFP_PS          0x00100000
#define WINED3D_SHADER_CONST_FFP_COLOR_KEY   0x00200000
443

444
enum wined3d_shader_register_type
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
{
    WINED3DSPR_TEMP = 0,
    WINED3DSPR_INPUT = 1,
    WINED3DSPR_CONST = 2,
    WINED3DSPR_ADDR = 3,
    WINED3DSPR_TEXTURE = 3,
    WINED3DSPR_RASTOUT = 4,
    WINED3DSPR_ATTROUT = 5,
    WINED3DSPR_TEXCRDOUT = 6,
    WINED3DSPR_OUTPUT = 6,
    WINED3DSPR_CONSTINT = 7,
    WINED3DSPR_COLOROUT = 8,
    WINED3DSPR_DEPTHOUT = 9,
    WINED3DSPR_SAMPLER = 10,
    WINED3DSPR_CONST2 = 11,
    WINED3DSPR_CONST3 = 12,
    WINED3DSPR_CONST4 = 13,
    WINED3DSPR_CONSTBOOL = 14,
    WINED3DSPR_LOOP = 15,
    WINED3DSPR_TEMPFLOAT16 = 16,
    WINED3DSPR_MISCTYPE = 17,
    WINED3DSPR_LABEL = 18,
    WINED3DSPR_PREDICATE = 19,
468
    WINED3DSPR_IMMCONST,
469
    WINED3DSPR_CONSTBUFFER,
470
    WINED3DSPR_IMMCONSTBUFFER,
471
    WINED3DSPR_PRIMID,
472
    WINED3DSPR_NULL,
473
    WINED3DSPR_RESOURCE,
474
    WINED3DSPR_UAV,
475
    WINED3DSPR_OUTPOINTID,
476
    WINED3DSPR_FORKINSTID,
477
    WINED3DSPR_JOININSTID,
478
    WINED3DSPR_INCONTROLPOINT,
479
    WINED3DSPR_OUTCONTROLPOINT,
480
    WINED3DSPR_PATCHCONST,
481
    WINED3DSPR_TESSCOORD,
482
    WINED3DSPR_GROUPSHAREDMEM,
483
    WINED3DSPR_THREADID,
484
    WINED3DSPR_THREADGROUPID,
485
    WINED3DSPR_LOCALTHREADID,
486
    WINED3DSPR_LOCALTHREADINDEX,
487
    WINED3DSPR_IDXTEMP,
488
    WINED3DSPR_STREAM,
489 490
    WINED3DSPR_FUNCTIONBODY,
    WINED3DSPR_FUNCTIONPOINTER,
491
    WINED3DSPR_COVERAGE,
492
    WINED3DSPR_SAMPLEMASK,
493
    WINED3DSPR_GSINSTID,
494 495
    WINED3DSPR_DEPTHOUTGE,
    WINED3DSPR_DEPTHOUTLE,
496
    WINED3DSPR_RASTERIZER,
497
};
498

499 500 501 502 503 504
enum wined3d_data_type
{
    WINED3D_DATA_FLOAT,
    WINED3D_DATA_INT,
    WINED3D_DATA_RESOURCE,
    WINED3D_DATA_SAMPLER,
505
    WINED3D_DATA_UAV,
506
    WINED3D_DATA_UINT,
507 508
    WINED3D_DATA_UNORM,
    WINED3D_DATA_SNORM,
509
    WINED3D_DATA_OPAQUE,
510 511
};

512 513
enum wined3d_immconst_type
{
514 515
    WINED3D_IMMCONST_SCALAR,
    WINED3D_IMMCONST_VEC4,
516 517
};

518
#define WINED3DSP_NOSWIZZLE (0u | (1u << 2) | (2u << 4) | (3u << 6))
519

520
enum wined3d_shader_src_modifier
521 522 523 524 525 526 527 528 529 530 531 532 533 534 535
{
    WINED3DSPSM_NONE = 0,
    WINED3DSPSM_NEG = 1,
    WINED3DSPSM_BIAS = 2,
    WINED3DSPSM_BIASNEG = 3,
    WINED3DSPSM_SIGN = 4,
    WINED3DSPSM_SIGNNEG = 5,
    WINED3DSPSM_COMP = 6,
    WINED3DSPSM_X2 = 7,
    WINED3DSPSM_X2NEG = 8,
    WINED3DSPSM_DZ = 9,
    WINED3DSPSM_DW = 10,
    WINED3DSPSM_ABS = 11,
    WINED3DSPSM_ABSNEG = 12,
    WINED3DSPSM_NOT = 13,
536
};
537

538 539 540 541 542
#define WINED3DSP_WRITEMASK_0   0x1u /* .x r */
#define WINED3DSP_WRITEMASK_1   0x2u /* .y g */
#define WINED3DSP_WRITEMASK_2   0x4u /* .z b */
#define WINED3DSP_WRITEMASK_3   0x8u /* .w a */
#define WINED3DSP_WRITEMASK_ALL 0xfu /* all */
543

544
enum wined3d_shader_dst_modifier
545 546 547 548 549
{
    WINED3DSPDM_NONE = 0,
    WINED3DSPDM_SATURATE = 1,
    WINED3DSPDM_PARTIALPRECISION = 2,
    WINED3DSPDM_MSAMPCENTROID = 4,
550
};
551

552 553
enum wined3d_shader_interpolation_mode
{
554
    WINED3DSIM_NONE = 0,
555 556 557 558 559 560 561 562 563
    WINED3DSIM_CONSTANT = 1,
    WINED3DSIM_LINEAR = 2,
    WINED3DSIM_LINEAR_CENTROID = 3,
    WINED3DSIM_LINEAR_NOPERSPECTIVE = 4,
    WINED3DSIM_LINEAR_NOPERSPECTIVE_CENTROID = 5,
    WINED3DSIM_LINEAR_SAMPLE = 6,
    WINED3DSIM_LINEAR_NOPERSPECTIVE_SAMPLE = 7,
};

564 565 566
#define WINED3D_PACKED_INTERPOLATION_SIZE 3
#define WINED3D_PACKED_INTERPOLATION_BIT_COUNT 3

567 568 569
enum wined3d_shader_global_flags
{
    WINED3DSGF_REFACTORING_ALLOWED               = 0x1,
570
    WINED3DSGF_FORCE_EARLY_DEPTH_STENCIL         = 0x4,
571 572 573
    WINED3DSGF_ENABLE_RAW_AND_STRUCTURED_BUFFERS = 0x8,
};

574 575 576 577 578 579
enum wined3d_shader_sync_flags
{
    WINED3DSSF_THREAD_GROUP        = 0x1,
    WINED3DSSF_GROUP_SHARED_MEMORY = 0x2,
};

580 581
enum wined3d_shader_uav_flags
{
582 583
    WINED3DSUF_GLOBALLY_COHERENT = 0x2,
    WINED3DSUF_ORDER_PRESERVING_COUNTER = 0x100,
584 585
};

586 587 588 589 590 591 592
enum wined3d_tessellator_domain
{
    WINED3D_TESSELLATOR_DOMAIN_LINE      = 1,
    WINED3D_TESSELLATOR_DOMAIN_TRIANGLE  = 2,
    WINED3D_TESSELLATOR_DOMAIN_QUAD      = 3,
};

593 594 595 596 597 598 599 600
enum wined3d_tessellator_output_primitive
{
    WINED3D_TESSELLATOR_OUTPUT_POINT        = 1,
    WINED3D_TESSELLATOR_OUTPUT_LINE         = 2,
    WINED3D_TESSELLATOR_OUTPUT_TRIANGLE_CW  = 3,
    WINED3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW = 4,
};

601 602 603 604 605 606 607 608
enum wined3d_tessellator_partitioning
{
    WINED3D_TESSELLATOR_PARTITIONING_INTEGER         = 1,
    WINED3D_TESSELLATOR_PARTITIONING_POW2            = 2,
    WINED3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD  = 3,
    WINED3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN = 4,
};

609
/* Undocumented opcode control to identify projective texture lookups in ps 2.0 and later */
610 611 612
#define WINED3DSI_TEXLD_PROJECT     0x1
#define WINED3DSI_TEXLD_BIAS        0x2
#define WINED3DSI_INDEXED_DYNAMIC   0x4
613 614
#define WINED3DSI_RESINFO_RCP_FLOAT 0x1
#define WINED3DSI_RESINFO_UINT      0x2
615
#define WINED3DSI_SAMPLE_INFO_UINT  0x1
616
#define WINED3DSI_SAMPLER_COMPARISON_MODE 0x1
617

618 619 620 621 622 623 624 625
#define WINED3DSI_PRECISE_X         0x100
#define WINED3DSI_PRECISE_Y         0x200
#define WINED3DSI_PRECISE_Z         0x400
#define WINED3DSI_PRECISE_W         0x800
#define WINED3DSI_PRECISE_XYZW      (WINED3DSI_PRECISE_X | WINED3DSI_PRECISE_Y \
                                    | WINED3DSI_PRECISE_Z | WINED3DSI_PRECISE_W)
#define WINED3DSI_PRECISE_SHIFT     8

626
enum wined3d_shader_rel_op
627
{
628 629 630 631 632 633 634
    WINED3D_SHADER_REL_OP_GT = 1,
    WINED3D_SHADER_REL_OP_EQ = 2,
    WINED3D_SHADER_REL_OP_GE = 3,
    WINED3D_SHADER_REL_OP_LT = 4,
    WINED3D_SHADER_REL_OP_NE = 5,
    WINED3D_SHADER_REL_OP_LE = 6,
};
635

636 637 638 639 640 641
enum wined3d_shader_conditional_op
{
    WINED3D_SHADER_CONDITIONAL_OP_NZ = 0,
    WINED3D_SHADER_CONDITIONAL_OP_Z  = 1
};

642 643 644 645 646
#define WINED3D_SM1_VS  0xfffeu
#define WINED3D_SM1_PS  0xffffu
#define WINED3D_SM4_PS  0x0000u
#define WINED3D_SM4_VS  0x0001u
#define WINED3D_SM4_GS  0x0002u
647
#define WINED3D_SM5_HS  0x0003u
648
#define WINED3D_SM5_DS  0x0004u
649
#define WINED3D_SM5_CS  0x0005u
650

651
/* Shader version tokens, and shader end tokens */
652 653
#define WINED3DPS_VERSION(major, minor) ((WINED3D_SM1_PS << 16) | ((major) << 8) | (minor))
#define WINED3DVS_VERSION(major, minor) ((WINED3D_SM1_VS << 16) | ((major) << 8) | (minor))
654

655
/* Shader backends */
656 657 658 659 660

/* TODO: Make this dynamic, based on shader limits ? */
#define MAX_ATTRIBS 16
#define MAX_REG_ADDR 1
#define MAX_REG_TEXCRD 8
661 662
#define MAX_REG_INPUT 32
#define MAX_REG_OUTPUT 32
663
#define WINED3D_MAX_CBS 15
664
#define WINED3D_MAX_CONSTS_B 16
665
#define WINED3D_MAX_CONSTS_I 16
666
#define WINED3D_MAX_VS_CONSTS_F 256
667
#define WINED3D_MAX_PS_CONSTS_F 224
668 669 670 671

/* FIXME: This needs to go up to 2048 for
 * Shader model 3 according to msdn (and for software shaders) */
#define MAX_LABELS 16
672

673 674
#define MAX_IMMEDIATE_CONSTANT_BUFFER_SIZE 4096

675
struct wined3d_string_buffer
676
{
677
    struct list entry;
678
    char *buffer;
679
    unsigned int buffer_size;
680
    unsigned int content_size;
681
};
682

683 684 685 686
enum WINED3D_SHADER_INSTRUCTION_HANDLER
{
    WINED3DSIH_ABS,
    WINED3DSIH_ADD,
687
    WINED3DSIH_AND,
688
    WINED3DSIH_ATOMIC_AND,
689
    WINED3DSIH_ATOMIC_CMP_STORE,
690
    WINED3DSIH_ATOMIC_IADD,
691
    WINED3DSIH_ATOMIC_IMAX,
692
    WINED3DSIH_ATOMIC_IMIN,
693
    WINED3DSIH_ATOMIC_OR,
694
    WINED3DSIH_ATOMIC_UMAX,
695
    WINED3DSIH_ATOMIC_UMIN,
696
    WINED3DSIH_ATOMIC_XOR,
697
    WINED3DSIH_BEM,
698
    WINED3DSIH_BFI,
699
    WINED3DSIH_BFREV,
700 701 702
    WINED3DSIH_BREAK,
    WINED3DSIH_BREAKC,
    WINED3DSIH_BREAKP,
703
    WINED3DSIH_BUFINFO,
704 705
    WINED3DSIH_CALL,
    WINED3DSIH_CALLNZ,
706
    WINED3DSIH_CASE,
707 708
    WINED3DSIH_CMP,
    WINED3DSIH_CND,
709
    WINED3DSIH_CONTINUE,
710
    WINED3DSIH_CONTINUEP,
711
    WINED3DSIH_COUNTBITS,
712
    WINED3DSIH_CRS,
713
    WINED3DSIH_CUT,
714
    WINED3DSIH_CUT_STREAM,
715
    WINED3DSIH_DCL,
716
    WINED3DSIH_DCL_CONSTANT_BUFFER,
717 718
    WINED3DSIH_DCL_FUNCTION_BODY,
    WINED3DSIH_DCL_FUNCTION_TABLE,
719
    WINED3DSIH_DCL_GLOBAL_FLAGS,
720
    WINED3DSIH_DCL_GS_INSTANCES,
721
    WINED3DSIH_DCL_HS_FORK_PHASE_INSTANCE_COUNT,
722
    WINED3DSIH_DCL_HS_JOIN_PHASE_INSTANCE_COUNT,
723
    WINED3DSIH_DCL_HS_MAX_TESSFACTOR,
724
    WINED3DSIH_DCL_IMMEDIATE_CONSTANT_BUFFER,
725
    WINED3DSIH_DCL_INDEX_RANGE,
726
    WINED3DSIH_DCL_INDEXABLE_TEMP,
727
    WINED3DSIH_DCL_INPUT,
728
    WINED3DSIH_DCL_INPUT_CONTROL_POINT_COUNT,
729
    WINED3DSIH_DCL_INPUT_PRIMITIVE,
730
    WINED3DSIH_DCL_INPUT_PS,
731
    WINED3DSIH_DCL_INPUT_PS_SGV,
732
    WINED3DSIH_DCL_INPUT_PS_SIV,
733
    WINED3DSIH_DCL_INPUT_SGV,
734
    WINED3DSIH_DCL_INPUT_SIV,
735
    WINED3DSIH_DCL_INTERFACE,
736
    WINED3DSIH_DCL_OUTPUT,
737
    WINED3DSIH_DCL_OUTPUT_CONTROL_POINT_COUNT,
738
    WINED3DSIH_DCL_OUTPUT_SIV,
739
    WINED3DSIH_DCL_OUTPUT_TOPOLOGY,
740
    WINED3DSIH_DCL_RESOURCE_RAW,
741
    WINED3DSIH_DCL_RESOURCE_STRUCTURED,
742
    WINED3DSIH_DCL_SAMPLER,
743
    WINED3DSIH_DCL_STREAM,
744
    WINED3DSIH_DCL_TEMPS,
745
    WINED3DSIH_DCL_TESSELLATOR_DOMAIN,
746
    WINED3DSIH_DCL_TESSELLATOR_OUTPUT_PRIMITIVE,
747
    WINED3DSIH_DCL_TESSELLATOR_PARTITIONING,
748
    WINED3DSIH_DCL_TGSM_RAW,
749
    WINED3DSIH_DCL_TGSM_STRUCTURED,
750
    WINED3DSIH_DCL_THREAD_GROUP,
751
    WINED3DSIH_DCL_UAV_RAW,
752
    WINED3DSIH_DCL_UAV_STRUCTURED,
753
    WINED3DSIH_DCL_UAV_TYPED,
754
    WINED3DSIH_DCL_VERTICES_OUT,
755
    WINED3DSIH_DEF,
756
    WINED3DSIH_DEFAULT,
757 758
    WINED3DSIH_DEFB,
    WINED3DSIH_DEFI,
759
    WINED3DSIH_DIV,
760
    WINED3DSIH_DP2,
761 762 763 764 765
    WINED3DSIH_DP2ADD,
    WINED3DSIH_DP3,
    WINED3DSIH_DP4,
    WINED3DSIH_DST,
    WINED3DSIH_DSX,
766
    WINED3DSIH_DSX_COARSE,
767
    WINED3DSIH_DSX_FINE,
768
    WINED3DSIH_DSY,
769
    WINED3DSIH_DSY_COARSE,
770
    WINED3DSIH_DSY_FINE,
771
    WINED3DSIH_ELSE,
772
    WINED3DSIH_EMIT,
773
    WINED3DSIH_EMIT_STREAM,
774 775 776
    WINED3DSIH_ENDIF,
    WINED3DSIH_ENDLOOP,
    WINED3DSIH_ENDREP,
777
    WINED3DSIH_ENDSWITCH,
778
    WINED3DSIH_EQ,
779
    WINED3DSIH_EVAL_SAMPLE_INDEX,
780 781
    WINED3DSIH_EXP,
    WINED3DSIH_EXPP,
782
    WINED3DSIH_F16TOF32,
783
    WINED3DSIH_F32TOF16,
784
    WINED3DSIH_FCALL,
785 786 787
    WINED3DSIH_FIRSTBIT_HI,
    WINED3DSIH_FIRSTBIT_LO,
    WINED3DSIH_FIRSTBIT_SHI,
788
    WINED3DSIH_FRC,
789
    WINED3DSIH_FTOI,
790
    WINED3DSIH_FTOU,
791
    WINED3DSIH_GATHER4,
792
    WINED3DSIH_GATHER4_C,
793
    WINED3DSIH_GATHER4_PO,
794
    WINED3DSIH_GATHER4_PO_C,
795
    WINED3DSIH_GE,
796
    WINED3DSIH_HS_CONTROL_POINT_PHASE,
797
    WINED3DSIH_HS_DECLS,
798
    WINED3DSIH_HS_FORK_PHASE,
799
    WINED3DSIH_HS_JOIN_PHASE,
800
    WINED3DSIH_IADD,
801
    WINED3DSIH_IBFE,
802
    WINED3DSIH_IEQ,
803 804
    WINED3DSIH_IF,
    WINED3DSIH_IFC,
805
    WINED3DSIH_IGE,
806
    WINED3DSIH_ILT,
807
    WINED3DSIH_IMAD,
808
    WINED3DSIH_IMAX,
809
    WINED3DSIH_IMIN,
810
    WINED3DSIH_IMM_ATOMIC_ALLOC,
811
    WINED3DSIH_IMM_ATOMIC_AND,
812
    WINED3DSIH_IMM_ATOMIC_CMP_EXCH,
813
    WINED3DSIH_IMM_ATOMIC_CONSUME,
814
    WINED3DSIH_IMM_ATOMIC_EXCH,
815
    WINED3DSIH_IMM_ATOMIC_IADD,
816
    WINED3DSIH_IMM_ATOMIC_IMAX,
817
    WINED3DSIH_IMM_ATOMIC_IMIN,
818
    WINED3DSIH_IMM_ATOMIC_OR,
819
    WINED3DSIH_IMM_ATOMIC_UMAX,
820
    WINED3DSIH_IMM_ATOMIC_UMIN,
821
    WINED3DSIH_IMM_ATOMIC_XOR,
822
    WINED3DSIH_IMUL,
823
    WINED3DSIH_INE,
824
    WINED3DSIH_INEG,
825
    WINED3DSIH_ISHL,
826
    WINED3DSIH_ISHR,
827
    WINED3DSIH_ITOF,
828
    WINED3DSIH_LABEL,
829
    WINED3DSIH_LD,
830
    WINED3DSIH_LD2DMS,
831
    WINED3DSIH_LD_RAW,
832
    WINED3DSIH_LD_STRUCTURED,
833
    WINED3DSIH_LD_UAV_TYPED,
834
    WINED3DSIH_LIT,
835
    WINED3DSIH_LOD,
836 837 838 839
    WINED3DSIH_LOG,
    WINED3DSIH_LOGP,
    WINED3DSIH_LOOP,
    WINED3DSIH_LRP,
840
    WINED3DSIH_LT,
841 842 843 844 845 846 847 848 849 850
    WINED3DSIH_M3x2,
    WINED3DSIH_M3x3,
    WINED3DSIH_M3x4,
    WINED3DSIH_M4x3,
    WINED3DSIH_M4x4,
    WINED3DSIH_MAD,
    WINED3DSIH_MAX,
    WINED3DSIH_MIN,
    WINED3DSIH_MOV,
    WINED3DSIH_MOVA,
851
    WINED3DSIH_MOVC,
852
    WINED3DSIH_MUL,
853
    WINED3DSIH_NE,
854
    WINED3DSIH_NOP,
855
    WINED3DSIH_NOT,
856
    WINED3DSIH_NRM,
857
    WINED3DSIH_OR,
858 859 860 861
    WINED3DSIH_PHASE,
    WINED3DSIH_POW,
    WINED3DSIH_RCP,
    WINED3DSIH_REP,
862
    WINED3DSIH_RESINFO,
863
    WINED3DSIH_RET,
864
    WINED3DSIH_RETP,
865
    WINED3DSIH_ROUND_NE,
866
    WINED3DSIH_ROUND_NI,
867
    WINED3DSIH_ROUND_PI,
868
    WINED3DSIH_ROUND_Z,
869
    WINED3DSIH_RSQ,
870
    WINED3DSIH_SAMPLE,
871
    WINED3DSIH_SAMPLE_B,
872
    WINED3DSIH_SAMPLE_C,
873
    WINED3DSIH_SAMPLE_C_LZ,
874
    WINED3DSIH_SAMPLE_GRAD,
875
    WINED3DSIH_SAMPLE_INFO,
876
    WINED3DSIH_SAMPLE_LOD,
877
    WINED3DSIH_SAMPLE_POS,
878 879 880 881 882
    WINED3DSIH_SETP,
    WINED3DSIH_SGE,
    WINED3DSIH_SGN,
    WINED3DSIH_SINCOS,
    WINED3DSIH_SLT,
883
    WINED3DSIH_SQRT,
884
    WINED3DSIH_STORE_RAW,
885
    WINED3DSIH_STORE_STRUCTURED,
886
    WINED3DSIH_STORE_UAV_TYPED,
887
    WINED3DSIH_SUB,
888
    WINED3DSIH_SWAPC,
889
    WINED3DSIH_SWITCH,
890
    WINED3DSIH_SYNC,
891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912
    WINED3DSIH_TEX,
    WINED3DSIH_TEXBEM,
    WINED3DSIH_TEXBEML,
    WINED3DSIH_TEXCOORD,
    WINED3DSIH_TEXDEPTH,
    WINED3DSIH_TEXDP3,
    WINED3DSIH_TEXDP3TEX,
    WINED3DSIH_TEXKILL,
    WINED3DSIH_TEXLDD,
    WINED3DSIH_TEXLDL,
    WINED3DSIH_TEXM3x2DEPTH,
    WINED3DSIH_TEXM3x2PAD,
    WINED3DSIH_TEXM3x2TEX,
    WINED3DSIH_TEXM3x3,
    WINED3DSIH_TEXM3x3DIFF,
    WINED3DSIH_TEXM3x3PAD,
    WINED3DSIH_TEXM3x3SPEC,
    WINED3DSIH_TEXM3x3TEX,
    WINED3DSIH_TEXM3x3VSPEC,
    WINED3DSIH_TEXREG2AR,
    WINED3DSIH_TEXREG2GB,
    WINED3DSIH_TEXREG2RGB,
913
    WINED3DSIH_UBFE,
914
    WINED3DSIH_UDIV,
915
    WINED3DSIH_UGE,
916
    WINED3DSIH_ULT,
917
    WINED3DSIH_UMAX,
918
    WINED3DSIH_UMIN,
919
    WINED3DSIH_UMUL,
920
    WINED3DSIH_USHR,
921
    WINED3DSIH_UTOF,
922
    WINED3DSIH_XOR,
923 924 925
    WINED3DSIH_TABLE_SIZE
};

926 927 928 929 930 931 932
struct wined3d_shader_version
{
    enum wined3d_shader_type type;
    BYTE major;
    BYTE minor;
};

933 934 935 936
struct wined3d_shader_resource_info
{
    enum wined3d_shader_resource_type type;
    enum wined3d_data_type data_type;
937
    unsigned int flags;
938
    unsigned int stride;
939 940
};

941 942
#define WINED3D_SAMPLER_DEFAULT ~0x0u

943 944 945 946 947 948 949 950 951 952 953 954 955 956
struct wined3d_shader_sampler_map_entry
{
    unsigned int resource_idx;
    unsigned int sampler_idx;
    unsigned int bind_idx;
};

struct wined3d_shader_sampler_map
{
    struct wined3d_shader_sampler_map_entry *entries;
    size_t size;
    size_t count;
};

957 958
struct wined3d_shader_immediate_constant_buffer
{
959
    unsigned int vec4_count;
960 961 962
    DWORD data[MAX_IMMEDIATE_CONSTANT_BUFFER_SIZE];
};

963 964 965 966 967 968 969 970
struct wined3d_shader_indexable_temp
{
    struct list entry;
    unsigned int register_idx;
    unsigned int register_size;
    unsigned int component_count;
};

971 972
#define WINED3D_SHADER_VERSION(major, minor) (((major) << 8) | (minor))

973
struct wined3d_shader_reg_maps
974
{
975
    struct wined3d_shader_version shader_version;
976 977 978
    BYTE texcoord;                                  /* MAX_REG_TEXCRD, 8 */
    BYTE address;                                   /* MAX_REG_ADDR, 1 */
    WORD labels;                                    /* MAX_LABELS, 16 */
979 980
    DWORD temporary;                                /* 32 */
    unsigned int temporary_count;
981
    DWORD *constf;                                  /* pixel, vertex */
982
    struct list indexable_temps;
983
    const struct wined3d_shader_immediate_constant_buffer *icb;
984 985 986 987 988 989 990
    union
    {
        DWORD texcoord_mask[MAX_REG_TEXCRD];        /* vertex < 3.0 */
        BYTE output_registers_mask[MAX_REG_OUTPUT]; /* vertex >= 3.0 */
    } u;
    DWORD input_registers;                          /* max(MAX_REG_INPUT, MAX_ATTRIBS), 32 */
    DWORD output_registers;                         /* MAX_REG_OUTPUT, 32 */
991
    WORD integer_constants;                         /* WINED3D_MAX_CONSTS_I, 16 */
992
    WORD boolean_constants;                         /* WINED3D_MAX_CONSTS_B, 16 */
993
    WORD local_int_consts;                          /* WINED3D_MAX_CONSTS_I, 16 */
994
    WORD local_bool_consts;                         /* WINED3D_MAX_CONSTS_B, 16 */
995
    UINT cb_sizes[WINED3D_MAX_CBS];
996

997
    struct wined3d_shader_resource_info resource_info[MAX_SHADER_RESOURCE_VIEWS];
998
    struct wined3d_shader_sampler_map sampler_map;
999
    DWORD sampler_comparison_mode;
1000 1001
    BYTE bumpmat;                                   /* MAX_TEXTURES, 8 */
    BYTE luminanceparams;                           /* MAX_TEXTURES, 8 */
1002
    struct wined3d_shader_resource_info uav_resource_info[MAX_UNORDERED_ACCESS_VIEWS];
1003 1004 1005 1006
    DWORD uav_read_mask : 8;                        /* MAX_UNORDERED_ACCESS_VIEWS, 8 */
    DWORD uav_counter_mask : 8;                     /* MAX_UNORDERED_ACCESS_VIEWS, 8 */

    DWORD clip_distance_mask : 8;                   /* MAX_CLIP_DISTANCES, 8 */
1007
    DWORD cull_distance_mask : 8;                   /* MAX_CLIP_DISTANCES, 8 */
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
    DWORD usesnrm        : 1;
    DWORD vpos           : 1;
    DWORD usesdsx        : 1;
    DWORD usesdsy        : 1;
    DWORD usestexldd     : 1;
    DWORD usesmova       : 1;
    DWORD usesfacing     : 1;
    DWORD usesrelconstF  : 1;
    DWORD fog            : 1;
    DWORD usestexldl     : 1;
    DWORD usesifc        : 1;
    DWORD usescall       : 1;
    DWORD usespow        : 1;
    DWORD point_size     : 1;
    DWORD vocp           : 1;
1023
    DWORD input_rel_addressing : 1;
1024
    DWORD viewport_array : 1;
1025 1026
    DWORD sample_mask    : 1;
    DWORD padding        : 14;
1027

1028 1029
    DWORD rt_mask; /* Used render targets, 32 max. */

1030
    /* Whether or not loops are used in this shader, and nesting depth */
1031 1032
    unsigned int loop_depth;
    unsigned int min_rel_offset, max_rel_offset;
1033 1034 1035 1036

    struct wined3d_shader_tgsm *tgsm;
    SIZE_T tgsm_capacity;
    unsigned int tgsm_count;
1037
};
1038

1039 1040 1041 1042 1043 1044 1045 1046
/* Keeps track of details for TEX_M#x# instructions which need to maintain
 * state information between multiple instructions. */
struct wined3d_shader_tex_mx
{
    unsigned int current_row;
    DWORD texcoord_w[2];
};

1047
struct wined3d_shader_parser_state
1048
{
1049 1050 1051
    unsigned int current_loop_depth;
    unsigned int current_loop_reg;
    BOOL in_subroutine;
1052 1053
};

1054 1055
struct wined3d_shader_context
{
1056
    const struct wined3d_shader *shader;
1057
    const struct wined3d_gl_info *gl_info;
1058
    const struct wined3d_shader_reg_maps *reg_maps;
1059
    struct wined3d_string_buffer *buffer;
1060
    struct wined3d_shader_tex_mx *tex_mx;
1061
    struct wined3d_shader_parser_state *state;
1062
    void *backend_data;
1063 1064
};

1065 1066 1067 1068 1069 1070
struct wined3d_shader_register_index
{
    const struct wined3d_shader_src_param *rel_addr;
    unsigned int offset;
};

1071 1072
struct wined3d_shader_register
{
1073
    enum wined3d_shader_register_type type;
1074
    enum wined3d_data_type data_type;
1075
    struct wined3d_shader_register_index idx[2];
1076
    enum wined3d_immconst_type immconst_type;
1077 1078 1079 1080 1081
    union
    {
        DWORD immconst_data[4];
        unsigned fp_body_idx;
    } u;
1082 1083
};

1084 1085
struct wined3d_shader_dst_param
{
1086
    struct wined3d_shader_register reg;
1087
    DWORD write_mask;
1088
    DWORD modifiers;
1089
    DWORD shift;
1090 1091
};

1092 1093
struct wined3d_shader_src_param
{
1094
    struct wined3d_shader_register reg;
1095
    DWORD swizzle;
1096
    enum wined3d_shader_src_modifier modifiers;
1097 1098
};

1099 1100 1101 1102 1103 1104
struct wined3d_shader_index_range
{
    struct wined3d_shader_dst_param first_register;
    unsigned int last_register;
};

1105 1106 1107 1108
struct wined3d_shader_semantic
{
    enum wined3d_decl_usage usage;
    UINT usage_idx;
1109
    enum wined3d_shader_resource_type resource_type;
1110
    enum wined3d_data_type resource_data_type;
1111 1112 1113
    struct wined3d_shader_dst_param reg;
};

1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
enum wined3d_shader_input_sysval_semantic
{
    WINED3D_SIV_POSITION                     = 1,
    WINED3D_SIV_CLIP_DISTANCE                = 2,
    WINED3D_SIV_CULL_DISTANCE                = 3,
    WINED3D_SIV_RENDER_TARGET_ARRAY_INDEX    = 4,
    WINED3D_SIV_VIEWPORT_ARRAY_INDEX         = 5,
    WINED3D_SIV_VERTEX_ID                    = 6,
    WINED3D_SIV_PRIMITIVE_ID                 = 7,
    WINED3D_SIV_INSTANCE_ID                  = 8,
    WINED3D_SIV_IS_FRONT_FACE                = 9,
    WINED3D_SIV_SAMPLE_INDEX                 = 10,
    WINED3D_SIV_QUAD_U0_TESS_FACTOR          = 11,
    WINED3D_SIV_QUAD_V0_TESS_FACTOR          = 12,
    WINED3D_SIV_QUAD_U1_TESS_FACTOR          = 13,
    WINED3D_SIV_QUAD_V1_TESS_FACTOR          = 14,
    WINED3D_SIV_QUAD_U_INNER_TESS_FACTOR     = 15,
    WINED3D_SIV_QUAD_V_INNER_TESS_FACTOR     = 16,
    WINED3D_SIV_TRIANGLE_U_TESS_FACTOR       = 17,
    WINED3D_SIV_TRIANGLE_V_TESS_FACTOR       = 18,
    WINED3D_SIV_TRIANGLE_W_TESS_FACTOR       = 19,
    WINED3D_SIV_TRIANGLE_INNER_TESS_FACTOR   = 20,
    WINED3D_SIV_LINE_DETAIL_TESS_FACTOR      = 21,
    WINED3D_SIV_LINE_DENSITY_TESS_FACTOR     = 22,
};

1140 1141 1142
struct wined3d_shader_register_semantic
{
    struct wined3d_shader_dst_param reg;
1143
    enum wined3d_shader_input_sysval_semantic sysval_semantic;
1144 1145
};

1146 1147 1148 1149 1150 1151
struct wined3d_shader_structured_resource
{
    struct wined3d_shader_dst_param reg;
    unsigned int byte_stride;
};

1152 1153 1154
struct wined3d_shader_tgsm
{
    unsigned int size;
1155
    unsigned int stride;
1156 1157
};

1158 1159 1160 1161 1162 1163
struct wined3d_shader_tgsm_raw
{
    struct wined3d_shader_dst_param reg;
    unsigned int byte_count;
};

1164 1165 1166 1167 1168 1169 1170
struct wined3d_shader_tgsm_structured
{
    struct wined3d_shader_dst_param reg;
    unsigned int byte_stride;
    unsigned int structure_count;
};

1171 1172 1173 1174 1175
struct wined3d_shader_thread_group_size
{
    unsigned int x, y, z;
};

1176 1177 1178 1179 1180 1181 1182 1183
struct wined3d_shader_function_table_pointer
{
    unsigned int index;
    unsigned int array_size;
    unsigned int body_count;
    unsigned int table_count;
};

1184 1185 1186 1187 1188
struct wined3d_shader_texel_offset
{
    signed char u, v, w;
};

1189 1190 1191 1192 1193 1194
struct wined3d_shader_primitive_type
{
    enum wined3d_primitive_type type;
    unsigned int patch_vertex_count;
};

1195
struct wined3d_shader_instruction
1196
{
1197
    const struct wined3d_shader_context *ctx;
1198
    enum WINED3D_SHADER_INSTRUCTION_HANDLER handler_idx;
1199
    DWORD flags;
1200 1201
    unsigned int dst_count;
    unsigned int src_count;
1202
    const struct wined3d_shader_dst_param *dst;
1203
    const struct wined3d_shader_src_param *src;
1204
    struct wined3d_shader_texel_offset texel_offset;
1205 1206
    BOOL coissue;
    const struct wined3d_shader_src_param *predicate;
1207 1208 1209
    union
    {
        struct wined3d_shader_semantic semantic;
1210
        struct wined3d_shader_register_semantic register_semantic;
1211
        struct wined3d_shader_primitive_type primitive_type;
1212
        struct wined3d_shader_dst_param dst;
1213
        struct wined3d_shader_src_param src;
1214 1215
        unsigned int count;
        unsigned int index;
1216
        const struct wined3d_shader_immediate_constant_buffer *icb;
1217
        struct wined3d_shader_structured_resource structured_resource;
1218
        struct wined3d_shader_tgsm_raw tgsm_raw;
1219
        struct wined3d_shader_tgsm_structured tgsm_structured;
1220
        struct wined3d_shader_thread_group_size thread_group_size;
1221
        enum wined3d_tessellator_domain tessellator_domain;
1222
        enum wined3d_tessellator_output_primitive tessellator_output_primitive;
1223
        enum wined3d_tessellator_partitioning tessellator_partitioning;
1224
        float max_tessellation_factor;
1225
        struct wined3d_shader_index_range index_range;
1226
        struct wined3d_shader_indexable_temp indexable_temp;
1227
        struct wined3d_shader_function_table_pointer fp;
1228
    } declaration;
1229 1230
};

1231 1232 1233 1234 1235
static inline BOOL wined3d_shader_instruction_has_texel_offset(const struct wined3d_shader_instruction *ins)
{
    return ins->texel_offset.u || ins->texel_offset.v || ins->texel_offset.w;
}

1236 1237
struct wined3d_shader_attribute
{
1238
    enum wined3d_decl_usage usage;
1239 1240 1241
    UINT usage_idx;
};

1242 1243 1244 1245 1246 1247 1248
struct wined3d_shader_loop_control
{
    unsigned int count;
    unsigned int start;
    int step;
};

1249 1250
struct wined3d_shader_frontend
{
1251 1252
    void *(*shader_init)(const DWORD *byte_code, size_t byte_code_size,
            const struct wined3d_shader_signature *output_signature);
1253
    void (*shader_free)(void *data);
1254
    void (*shader_read_header)(void *data, const DWORD **ptr, struct wined3d_shader_version *shader_version);
1255
    void (*shader_read_instruction)(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins);
1256
    BOOL (*shader_is_end)(void *data, const DWORD **ptr);
1257 1258
};

1259 1260
extern const struct wined3d_shader_frontend sm1_shader_frontend DECLSPEC_HIDDEN;
extern const struct wined3d_shader_frontend sm4_shader_frontend DECLSPEC_HIDDEN;
1261

1262 1263 1264
enum wined3d_shader_type wined3d_get_sm4_shader_type(const DWORD *byte_code,
        size_t byte_code_size) DECLSPEC_HIDDEN;

1265
typedef void (*SHADER_HANDLER)(const struct wined3d_shader_instruction *);
1266

1267
#define WINED3D_SHADER_CAP_VS_CLIPPING      0x00000001
1268
#define WINED3D_SHADER_CAP_SRGB_WRITE       0x00000002
1269
#define WINED3D_SHADER_CAP_DOUBLE_PRECISION 0x00000004
1270

1271 1272
struct shader_caps
{
1273 1274
    unsigned int vs_version;
    unsigned int hs_version;
1275
    unsigned int ds_version;
1276 1277
    unsigned int gs_version;
    unsigned int ps_version;
1278
    unsigned int cs_version;
1279

1280 1281 1282
    DWORD vs_uniform_count;
    DWORD ps_uniform_count;
    float ps_1x_max_value;
1283
    DWORD varying_count;
1284

1285
    DWORD wined3d_caps;
1286 1287
};

1288
enum wined3d_gl_resource_type
1289
{
1290 1291 1292 1293 1294
    WINED3D_GL_RES_TYPE_TEX_1D          = 0,
    WINED3D_GL_RES_TYPE_TEX_2D          = 1,
    WINED3D_GL_RES_TYPE_TEX_3D          = 2,
    WINED3D_GL_RES_TYPE_TEX_CUBE        = 3,
    WINED3D_GL_RES_TYPE_TEX_RECT        = 4,
1295
    WINED3D_GL_RES_TYPE_BUFFER          = 5,
1296 1297
    WINED3D_GL_RES_TYPE_RB              = 6,
    WINED3D_GL_RES_TYPE_COUNT           = 7,
1298 1299
};

1300 1301 1302 1303 1304
enum wined3d_vertex_processing_mode
{
    WINED3D_VP_MODE_FF,
    WINED3D_VP_MODE_SHADER,
    WINED3D_VP_MODE_NONE,
1305 1306
};

1307 1308
#define WINED3D_CONST_NUM_UNUSED ~0U

1309 1310 1311 1312 1313 1314
enum wined3d_ffp_ps_fog_mode
{
    WINED3D_FFP_PS_FOG_OFF,
    WINED3D_FFP_PS_FOG_LINEAR,
    WINED3D_FFP_PS_FOG_EXP,
    WINED3D_FFP_PS_FOG_EXP2,
1315 1316
};

1317 1318 1319
/* Stateblock dependent parameters which have to be hardcoded
 * into the shader code
 */
1320

1321
#define WINED3D_PSARGS_PROJECTED (1u << 3)
1322
#define WINED3D_PSARGS_TEXTRANSFORM_SHIFT 4
1323
#define WINED3D_PSARGS_TEXTRANSFORM_MASK 0xfu
1324
#define WINED3D_PSARGS_TEXTYPE_SHIFT 2
1325
#define WINED3D_PSARGS_TEXTYPE_MASK 0x3u
1326

1327 1328
/* Used for Shader Model 1 pixel shaders to track the bound texture
 * type. 2D and RECT textures are separated through NP2 fixup. */
1329 1330 1331 1332 1333 1334
enum wined3d_shader_tex_types
{
    WINED3D_SHADER_TEX_2D   = 0,
    WINED3D_SHADER_TEX_3D   = 1,
    WINED3D_SHADER_TEX_CUBE = 2,
};
1335

1336 1337
struct ps_compile_args
{
1338
    struct color_fixup_desc     color_fixup[MAX_FRAGMENT_SAMPLERS];
1339
    enum wined3d_vertex_processing_mode vp_mode;
1340
    enum wined3d_ffp_ps_fog_mode fog;
1341
    WORD                        tex_transform; /* ps 1.0-1.3, 4 textures */
1342
    WORD                        tex_types; /* ps 1.0 - 1.4, 6 textures */
1343
    WORD                        srgb_correction;
1344
    /* Bitmap for NP2 texcoord fixups (16 samplers max currently).
1345 1346
       D3D9 has a limit of 16 samplers and the fixup is superfluous
       in D3D10 (unconditional NP2 support mandatory). */
1347
    WORD                        np2_fixup;
1348
    WORD shadow; /* MAX_FRAGMENT_SAMPLERS, 16 */
1349
    WORD texcoords_initialized; /* MAX_TEXTURES, 8 */
1350 1351 1352
    DWORD pointsprite : 1;
    DWORD flatshading : 1;
    DWORD alpha_test_func : 3;
1353 1354
    DWORD render_offscreen : 1;
    DWORD padding : 26;
1355 1356
};

1357 1358
enum fog_src_type
{
1359 1360 1361 1362
    VS_FOG_Z        = 0,
    VS_FOG_COORD    = 1
};

1363 1364 1365 1366 1367 1368
struct vs_compile_args
{
    BYTE fog_src;
    BYTE clip_enabled : 1;
    BYTE point_size : 1;
    BYTE per_vertex_point_size : 1;
1369
    BYTE flatshading : 1;
1370 1371
    BYTE next_shader_type : 3;
    BYTE padding : 1;
1372
    WORD swizzle_map;   /* MAX_ATTRIBS, 16 */
1373
    unsigned int next_shader_input_count;
1374
    DWORD interpolation_mode[WINED3D_PACKED_INTERPOLATION_SIZE];
1375 1376
};

1377 1378 1379 1380 1381 1382 1383
struct ds_compile_args
{
    enum wined3d_tessellator_output_primitive tessellator_output_primitive;
    enum wined3d_tessellator_partitioning tessellator_partitioning;
    unsigned int output_count : 16;
    unsigned int next_shader_type : 3;
    unsigned int render_offscreen : 1;
1384
    unsigned int padding : 12;
1385
    DWORD interpolation_mode[WINED3D_PACKED_INTERPOLATION_SIZE];
1386 1387
};

1388 1389
struct gs_compile_args
{
1390
    unsigned int output_count;
1391
    enum wined3d_primitive_type primitive_type;
1392
    DWORD interpolation_mode[WINED3D_PACKED_INTERPOLATION_SIZE];
1393 1394
};

1395
struct wined3d_context;
1396
struct wined3d_state;
1397
struct fragment_pipeline;
1398
struct wined3d_vertex_pipe_ops;
1399

1400 1401
struct wined3d_shader_backend_ops
{
1402
    void (*shader_handle_instruction)(const struct wined3d_shader_instruction *);
1403
    void (*shader_precompile)(void *shader_priv, struct wined3d_shader *shader);
1404
    void (*shader_select)(void *shader_priv, struct wined3d_context *context,
1405
            const struct wined3d_state *state);
1406 1407
    void (*shader_select_compute)(void *shader_priv, struct wined3d_context *context,
            const struct wined3d_state *state);
1408
    void (*shader_disable)(void *shader_priv, struct wined3d_context *context);
1409 1410
    void (*shader_update_float_vertex_constants)(struct wined3d_device *device, UINT start, UINT count);
    void (*shader_update_float_pixel_constants)(struct wined3d_device *device, UINT start, UINT count);
1411
    void (*shader_load_constants)(void *shader_priv, struct wined3d_context *context,
1412
            const struct wined3d_state *state);
1413
    void (*shader_destroy)(struct wined3d_shader *shader);
1414 1415
    HRESULT (*shader_alloc_private)(struct wined3d_device *device, const struct wined3d_vertex_pipe_ops *vertex_pipe,
            const struct fragment_pipeline *fragment_pipe);
1416
    void (*shader_free_private)(struct wined3d_device *device);
1417 1418
    BOOL (*shader_allocate_context_data)(struct wined3d_context *context);
    void (*shader_free_context_data)(struct wined3d_context *context);
1419
    void (*shader_init_context_state)(struct wined3d_context *context);
1420
    void (*shader_get_caps)(const struct wined3d_gl_info *gl_info, struct shader_caps *caps);
1421
    BOOL (*shader_color_fixup_supported)(struct color_fixup_desc fixup);
1422
    BOOL (*shader_has_ffp_proj_control)(void *shader_priv);
1423
};
1424

1425 1426 1427
extern const struct wined3d_shader_backend_ops glsl_shader_backend DECLSPEC_HIDDEN;
extern const struct wined3d_shader_backend_ops arb_program_shader_backend DECLSPEC_HIDDEN;
extern const struct wined3d_shader_backend_ops none_shader_backend DECLSPEC_HIDDEN;
1428

1429
#define GL_EXTCALL(f) (gl_info->gl_ops.ext.p_##f)
1430

1431 1432 1433 1434
#define D3DCOLOR_B_R(dw) (((dw) >> 16) & 0xff)
#define D3DCOLOR_B_G(dw) (((dw) >>  8) & 0xff)
#define D3DCOLOR_B_B(dw) (((dw) >>  0) & 0xff)
#define D3DCOLOR_B_A(dw) (((dw) >> 24) & 0xff)
1435

1436 1437 1438 1439 1440 1441 1442
static inline void wined3d_color_from_d3dcolor(struct wined3d_color *wined3d_color, DWORD d3d_color)
{
    wined3d_color->r = D3DCOLOR_B_R(d3d_color) / 255.0f;
    wined3d_color->g = D3DCOLOR_B_G(d3d_color) / 255.0f;
    wined3d_color->b = D3DCOLOR_B_B(d3d_color) / 255.0f;
    wined3d_color->a = D3DCOLOR_B_A(d3d_color) / 255.0f;
}
1443

1444
#define HIGHEST_TRANSFORMSTATE WINED3D_TS_WORLD_MATRIX(255) /* Highest value in wined3d_transform_state. */
1445

1446 1447 1448
void wined3d_check_gl_call(const struct wined3d_gl_info *gl_info,
        const char *file, unsigned int line, const char *name) DECLSPEC_HIDDEN;

1449 1450
/* Checking of API calls */
/* --------------------- */
1451
#ifndef WINE_NO_DEBUG_MSGS
1452 1453
#define checkGLcall(A)                                              \
do {                                                                \
1454 1455 1456
    if (__WINE_IS_DEBUG_ON(_ERR, &__wine_dbch_d3d)                  \
            && !gl_info->supported[ARB_DEBUG_OUTPUT])               \
        wined3d_check_gl_call(gl_info, __FILE__, __LINE__, A);      \
1457
} while(0)
1458
#else
1459
#define checkGLcall(A) do {} while(0)
1460
#endif
1461

1462 1463 1464
struct wined3d_bo_address
{
    GLuint buffer_object;
1465
    BYTE *addr;
1466 1467
};

1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478
struct wined3d_const_bo_address
{
    GLuint buffer_object;
    const BYTE *addr;
};

static inline struct wined3d_const_bo_address *wined3d_const_bo_address(struct wined3d_bo_address *data)
{
    return (struct wined3d_const_bo_address *)data;
}

1479 1480
struct wined3d_stream_info_element
{
1481
    const struct wined3d_format *format;
1482
    struct wined3d_bo_address data;
1483
    GLsizei stride;
1484 1485
    unsigned int stream_idx;
    unsigned int divisor;
1486 1487 1488 1489 1490
};

struct wined3d_stream_info
{
    struct wined3d_stream_info_element elements[MAX_ATTRIBS];
1491 1492
    DWORD position_transformed : 1;
    DWORD all_vbo : 1;
1493 1494 1495 1496
    WORD swizzle_map; /* MAX_ATTRIBS, 16 */
    WORD use_map; /* MAX_ATTRIBS, 16 */
};

1497 1498 1499 1500
void wined3d_stream_info_from_declaration(struct wined3d_stream_info *stream_info,
        const struct wined3d_state *state, const struct wined3d_gl_info *gl_info,
        const struct wined3d_d3d_info *d3d_info) DECLSPEC_HIDDEN;

1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523
struct wined3d_direct_dispatch_parameters
{
    unsigned int group_count_x;
    unsigned int group_count_y;
    unsigned int group_count_z;
};

struct wined3d_indirect_dispatch_parameters
{
    struct wined3d_buffer *buffer;
    unsigned int offset;
};

struct wined3d_dispatch_parameters
{
    BOOL indirect;
    union
    {
        struct wined3d_direct_dispatch_parameters direct;
        struct wined3d_indirect_dispatch_parameters indirect;
    } u;
};

1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549
struct wined3d_direct_draw_parameters
{
    int base_vertex_idx;
    unsigned int start_idx;
    unsigned int index_count;
    unsigned int start_instance;
    unsigned int instance_count;
};

struct wined3d_indirect_draw_parameters
{
    struct wined3d_buffer *buffer;
    unsigned int offset;
};

struct wined3d_draw_parameters
{
    BOOL indirect;
    union
    {
        struct wined3d_direct_draw_parameters direct;
        struct wined3d_indirect_draw_parameters indirect;
    } u;
    BOOL indexed;
};

1550
void draw_primitive(struct wined3d_device *device, const struct wined3d_state *state,
1551
        const struct wined3d_draw_parameters *draw_parameters) DECLSPEC_HIDDEN;
1552
void dispatch_compute(struct wined3d_device *device, const struct wined3d_state *state,
1553
        const struct wined3d_dispatch_parameters *dispatch_parameters) DECLSPEC_HIDDEN;
1554
DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) DECLSPEC_HIDDEN;
1555

1556
#define eps 1e-8f
1557

1558 1559 1560
#define GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, tex_num) \
    (((((d3dvtVertexType) >> (16 + (2 * (tex_num)))) + 1) & 0x03) + 1)

1561 1562 1563 1564 1565 1566 1567
enum wined3d_pipeline
{
    WINED3D_PIPELINE_GRAPHICS,
    WINED3D_PIPELINE_COMPUTE,
    WINED3D_PIPELINE_COUNT,
};

1568 1569
/* Routines and structures related to state management */

1570 1571 1572
#define STATE_RENDER(a) (a)
#define STATE_IS_RENDER(a) ((a) >= STATE_RENDER(1) && (a) <= STATE_RENDER(WINEHIGHEST_RENDER_STATE))

1573 1574 1575 1576
#define STATE_TEXTURESTAGE(stage, num) \
    (STATE_RENDER(WINEHIGHEST_RENDER_STATE) + 1 + (stage) * (WINED3D_HIGHEST_TEXTURE_STATE + 1) + (num))
#define STATE_IS_TEXTURESTAGE(a) \
    ((a) >= STATE_TEXTURESTAGE(0, 1) && (a) <= STATE_TEXTURESTAGE(MAX_TEXTURES - 1, WINED3D_HIGHEST_TEXTURE_STATE))
1577

1578 1579
/* + 1 because samplers start with 0 */
#define STATE_SAMPLER(num) (STATE_TEXTURESTAGE(MAX_TEXTURES - 1, WINED3D_HIGHEST_TEXTURE_STATE) + 1 + (num))
1580
#define STATE_IS_SAMPLER(num) ((num) >= STATE_SAMPLER(0) && (num) <= STATE_SAMPLER(MAX_COMBINED_SAMPLERS - 1))
1581

1582 1583 1584
#define STATE_GRAPHICS_SHADER(a) (STATE_SAMPLER(MAX_COMBINED_SAMPLERS) + (a))
#define STATE_IS_GRAPHICS_SHADER(a) \
    ((a) >= STATE_GRAPHICS_SHADER(0) && (a) < STATE_GRAPHICS_SHADER(WINED3D_SHADER_TYPE_GRAPHICS_COUNT))
1585

1586 1587 1588 1589
#define STATE_GRAPHICS_CONSTANT_BUFFER(a) (STATE_GRAPHICS_SHADER(WINED3D_SHADER_TYPE_GRAPHICS_COUNT) + (a))
#define STATE_IS_GRAPHICS_CONSTANT_BUFFER(a) \
    ((a) >= STATE_GRAPHICS_CONSTANT_BUFFER(0) \
    && (a) < STATE_GRAPHICS_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GRAPHICS_COUNT))
1590

1591 1592
#define STATE_GRAPHICS_SHADER_RESOURCE_BINDING (STATE_GRAPHICS_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GRAPHICS_COUNT))
#define STATE_IS_GRAPHICS_SHADER_RESOURCE_BINDING(a) ((a) == STATE_GRAPHICS_SHADER_RESOURCE_BINDING)
1593

1594
#define STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING (STATE_GRAPHICS_SHADER_RESOURCE_BINDING + 1)
1595
#define STATE_IS_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING(a) ((a) == STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING)
1596

1597
#define STATE_TRANSFORM(a) (STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING + (a))
1598
#define STATE_IS_TRANSFORM(a) ((a) >= STATE_TRANSFORM(1) && (a) <= STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(255)))
1599

1600
#define STATE_STREAMSRC (STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(255)) + 1)
1601
#define STATE_IS_STREAMSRC(a) ((a) == STATE_STREAMSRC)
1602 1603
#define STATE_INDEXBUFFER (STATE_STREAMSRC + 1)
#define STATE_IS_INDEXBUFFER(a) ((a) == STATE_INDEXBUFFER)
1604

1605
#define STATE_VDECL (STATE_INDEXBUFFER + 1)
1606 1607
#define STATE_IS_VDECL(a) ((a) == STATE_VDECL)

1608
#define STATE_VIEWPORT (STATE_VDECL + 1)
1609 1610
#define STATE_IS_VIEWPORT(a) ((a) == STATE_VIEWPORT)

1611
#define STATE_LIGHT_TYPE (STATE_VIEWPORT + 1)
1612 1613
#define STATE_IS_LIGHT_TYPE(a) ((a) == STATE_LIGHT_TYPE)
#define STATE_ACTIVELIGHT(a) (STATE_LIGHT_TYPE + 1 + (a))
1614
#define STATE_IS_ACTIVELIGHT(a) ((a) >= STATE_ACTIVELIGHT(0) && (a) < STATE_ACTIVELIGHT(MAX_ACTIVE_LIGHTS))
1615

1616 1617 1618
#define STATE_SCISSORRECT (STATE_ACTIVELIGHT(MAX_ACTIVE_LIGHTS - 1) + 1)
#define STATE_IS_SCISSORRECT(a) ((a) == STATE_SCISSORRECT)

1619
#define STATE_CLIPPLANE(a) (STATE_SCISSORRECT + 1 + (a))
1620
#define STATE_IS_CLIPPLANE(a) ((a) >= STATE_CLIPPLANE(0) && (a) <= STATE_CLIPPLANE(MAX_CLIP_DISTANCES - 1))
1621

1622
#define STATE_MATERIAL (STATE_CLIPPLANE(MAX_CLIP_DISTANCES))
1623
#define STATE_IS_MATERIAL(a) ((a) == STATE_MATERIAL)
1624

1625 1626
#define STATE_RASTERIZER (STATE_MATERIAL + 1)
#define STATE_IS_RASTERIZER(a) ((a) == STATE_RASTERIZER)
1627

1628
#define STATE_POINTSPRITECOORDORIGIN (STATE_RASTERIZER + 1)
1629 1630
#define STATE_IS_POINTSPRITECOORDORIGIN(a) ((a) == STATE_POINTSPRITECOORDORIGIN)

1631 1632 1633
#define STATE_BASEVERTEXINDEX  (STATE_POINTSPRITECOORDORIGIN + 1)
#define STATE_IS_BASEVERTEXINDEX(a) ((a) == STATE_BASEVERTEXINDEX)

1634 1635 1636
#define STATE_FRAMEBUFFER (STATE_BASEVERTEXINDEX + 1)
#define STATE_IS_FRAMEBUFFER(a) ((a) == STATE_FRAMEBUFFER)

1637 1638
#define STATE_POINT_ENABLE (STATE_FRAMEBUFFER + 1)
#define STATE_IS_POINT_ENABLE(a) ((a) == STATE_POINT_ENABLE)
1639

1640
#define STATE_COLOR_KEY (STATE_POINT_ENABLE + 1)
1641 1642
#define STATE_IS_COLOR_KEY(a) ((a) == STATE_COLOR_KEY)

1643 1644 1645
#define STATE_STREAM_OUTPUT (STATE_COLOR_KEY + 1)
#define STATE_IS_STREAM_OUTPUT(a) ((a) == STATE_STREAM_OUTPUT)

1646 1647 1648 1649
#define STATE_BLEND (STATE_STREAM_OUTPUT + 1)
#define STATE_IS_BLEND(a) ((a) == STATE_BLEND)

#define STATE_COMPUTE_OFFSET (STATE_BLEND + 1)
1650 1651 1652 1653 1654 1655 1656

#define STATE_COMPUTE_SHADER (STATE_COMPUTE_OFFSET)
#define STATE_IS_COMPUTE_SHADER(a) ((a) == STATE_COMPUTE_SHADER)

#define STATE_COMPUTE_CONSTANT_BUFFER (STATE_COMPUTE_SHADER + 1)
#define STATE_IS_COMPUTE_CONSTANT_BUFFER(a) ((a) == STATE_COMPUTE_CONSTANT_BUFFER)

1657 1658 1659 1660
#define STATE_COMPUTE_SHADER_RESOURCE_BINDING (STATE_COMPUTE_CONSTANT_BUFFER + 1)
#define STATE_IS_COMPUTE_SHADER_RESOURCE_BINDING(a) ((a) == STATE_COMPUTE_SHADER_RESOURCE_BINDING)

#define STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING (STATE_COMPUTE_SHADER_RESOURCE_BINDING + 1)
1661 1662 1663 1664
#define STATE_IS_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING(a) ((a) == STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING)

#define STATE_COMPUTE_HIGHEST (STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING)
#define STATE_HIGHEST (STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING)
1665

1666
#define STATE_IS_COMPUTE(a) ((a) >= STATE_COMPUTE_OFFSET && (a) <= STATE_COMPUTE_HIGHEST)
1667
#define STATE_COMPUTE_COUNT (STATE_COMPUTE_HIGHEST - STATE_COMPUTE_OFFSET + 1)
1668

1669 1670 1671
#define STATE_SHADER(a) ((a) != WINED3D_SHADER_TYPE_COMPUTE ? STATE_GRAPHICS_SHADER(a) : STATE_COMPUTE_SHADER)
#define STATE_CONSTANT_BUFFER(a) \
    ((a) != WINED3D_SHADER_TYPE_COMPUTE ? STATE_GRAPHICS_CONSTANT_BUFFER(a) : STATE_COMPUTE_CONSTANT_BUFFER)
1672 1673
#define STATE_UNORDERED_ACCESS_VIEW_BINDING(a) ((a) == WINED3D_PIPELINE_GRAPHICS ? \
    STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING : STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING)
1674

1675 1676 1677 1678 1679 1680
enum fogsource {
    FOGSOURCE_FFP,
    FOGSOURCE_VS,
    FOGSOURCE_COORD,
};

1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708
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 *context;
};

HRESULT wined3d_fence_create(struct wined3d_device *device, struct wined3d_fence **fence) DECLSPEC_HIDDEN;
void wined3d_fence_destroy(struct wined3d_fence *fence) DECLSPEC_HIDDEN;
void wined3d_fence_issue(struct wined3d_fence *fence, const struct wined3d_device *device) DECLSPEC_HIDDEN;
enum wined3d_fence_result wined3d_fence_wait(const struct wined3d_fence *fence,
        const struct wined3d_device *device) DECLSPEC_HIDDEN;

1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720
/* Direct3D terminology with little modifications. We do not have an issued
 * state because only the driver knows about it, but we have a created state
 * because D3D allows GetData() on a created query, but OpenGL doesn't. */
enum wined3d_query_state
{
    QUERY_CREATED,
    QUERY_SIGNALLED,
    QUERY_BUILDING
};

struct wined3d_query_ops
{
1721
    BOOL (*query_poll)(struct wined3d_query *query, DWORD flags);
1722
    BOOL (*query_issue)(struct wined3d_query *query, DWORD flags);
1723
    void (*query_destroy)(struct wined3d_query *query);
1724 1725 1726 1727 1728 1729 1730
};

struct wined3d_query
{
    LONG ref;

    void *parent;
1731
    const struct wined3d_parent_ops *parent_ops;
1732 1733 1734
    struct wined3d_device *device;
    enum wined3d_query_state state;
    enum wined3d_query_type type;
1735
    const void *data;
1736 1737
    DWORD data_size;
    const struct wined3d_query_ops *query_ops;
1738 1739 1740

    LONG counter_main, counter_retrieved;
    struct list poll_list_entry;
1741 1742
};

1743 1744
struct wined3d_event_query
{
1745 1746
    struct wined3d_query query;

1747
    struct wined3d_fence fence;
1748
    BOOL signalled;
1749 1750
};

1751 1752 1753 1754 1755 1756 1757
struct wined3d_occlusion_query
{
    struct wined3d_query query;

    struct list entry;
    GLuint id;
    struct wined3d_context *context;
1758
    UINT64 samples;
1759
    BOOL started;
1760 1761
};

1762 1763
struct wined3d_timestamp_query
{
1764 1765
    struct wined3d_query query;

1766 1767 1768
    struct list entry;
    GLuint id;
    struct wined3d_context *context;
1769
    UINT64 timestamp;
1770 1771 1772 1773 1774
};

void context_alloc_timestamp_query(struct wined3d_context *context, struct wined3d_timestamp_query *query) DECLSPEC_HIDDEN;
void context_free_timestamp_query(struct wined3d_timestamp_query *query) DECLSPEC_HIDDEN;

1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800
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 *context;
    unsigned int stream_idx;
    struct wined3d_query_data_so_statistics statistics;
    BOOL started;
};

void context_alloc_so_statistics_query(struct wined3d_context *context,
        struct wined3d_so_statistics_query *query) DECLSPEC_HIDDEN;
void context_free_so_statistics_query(struct wined3d_so_statistics_query *query) DECLSPEC_HIDDEN;

1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834
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 *context;
    struct wined3d_query_data_pipeline_statistics statistics;
    BOOL started;
};

void context_alloc_pipeline_statistics_query(struct wined3d_context *context,
        struct wined3d_pipeline_statistics_query *query) DECLSPEC_HIDDEN;
void context_free_pipeline_statistics_query(struct wined3d_pipeline_statistics_query *query) DECLSPEC_HIDDEN;

1835 1836 1837 1838 1839 1840
struct wined3d_gl_view
{
    GLenum target;
    GLuint name;
};

1841 1842
struct wined3d_rendertarget_info
{
1843
    struct wined3d_gl_view gl_view;
1844 1845
    struct wined3d_resource *resource;
    unsigned int sub_resource_idx;
1846
    unsigned int layer_count;
1847 1848
};

1849 1850
#define MAX_GL_FRAGMENT_SAMPLERS 32

1851
struct wined3d_context
1852 1853
{
    const struct wined3d_gl_info *gl_info;
1854
    const struct wined3d_d3d_info *d3d_info;
1855
    const struct StateEntry *state_table;
1856 1857 1858 1859 1860 1861 1862 1863
    /* State dirtification
     * dirtyArray is an array that contains markers for dirty states. numDirtyEntries states are dirty, their numbers are in indices
     * 0...numDirtyEntries - 1. isStateDirty is a redundant copy of the dirtyArray. Technically only one of them would be needed,
     * but with the help of both it is easy to find out if a state is dirty(just check the array index), and for applying dirty states
     * only numDirtyEntries array elements have to be checked, not STATE_HIGHEST states.
     */
    DWORD                   dirtyArray[STATE_HIGHEST + 1]; /* Won't get bigger than that, a state is never marked dirty 2 times */
    DWORD                   numDirtyEntries;
1864
    DWORD isStateDirty[STATE_HIGHEST / (sizeof(DWORD) * CHAR_BIT) + 1]; /* Bitmap to find out quickly if a state is dirty */
1865
    unsigned int dirty_compute_states[STATE_COMPUTE_COUNT / (sizeof(unsigned int) * CHAR_BIT) + 1];
1866

1867
    struct wined3d_device *device;
1868
    struct wined3d_swapchain *swapchain;
1869 1870 1871 1872 1873
    struct
    {
        struct wined3d_texture *texture;
        unsigned int sub_resource_idx;
    } current_rt;
1874
    DWORD                   tid;    /* Thread ID which owns this context at the moment */
1875

1876
    /* Stores some information about the context state for optimization */
1877 1878
    DWORD render_offscreen : 1;
    DWORD last_was_rhw : 1;             /* true iff last draw_primitive was in xyzrhw mode */
1879
    DWORD last_swizzle_map : 16; /* MAX_ATTRIBS, 16 */
1880 1881
    DWORD last_was_pshader : 1;
    DWORD last_was_vshader : 1;
1882 1883
    DWORD last_was_diffuse : 1;
    DWORD last_was_specular : 1;
1884
    DWORD last_was_normal : 1;
1885
    DWORD namedArraysLoaded : 1;
1886
    DWORD last_was_ffp_blit : 1;
1887 1888 1889 1890 1891 1892 1893
    DWORD last_was_blit : 1;
    DWORD last_was_ckey : 1;
    DWORD fog_coord : 1;
    DWORD fog_enabled : 1;
    DWORD current : 1;
    DWORD destroyed : 1;
    DWORD valid : 1;
1894

1895 1896
    DWORD texShaderBumpMap : 8;         /* MAX_TEXTURES, 8 */
    DWORD lastWasPow2Texture : 8;       /* MAX_TEXTURES, 8 */
1897
    DWORD fixed_function_usage_map : 8; /* MAX_TEXTURES, 8 */
1898
    DWORD lowest_disabled_stage : 4;    /* Max MAX_TEXTURES, 8 */
1899
    DWORD use_immediate_mode_draw : 1;
1900
    DWORD rebind_fbo : 1;
1901
    DWORD needs_set : 1;
1902
    DWORD hdc_is_private : 1;
1903

1904
    DWORD hdc_has_format : 1;           /* only meaningful if hdc_is_private */
1905
    DWORD update_shader_resource_bindings : 1;
1906
    DWORD update_compute_shader_resource_bindings : 1;
1907
    DWORD update_unordered_access_view_bindings : 1;
1908
    DWORD update_compute_unordered_access_view_bindings : 1;
1909
    DWORD uses_uavs : 1;
1910
    DWORD destroy_delayed : 1;
1911
    DWORD transform_feedback_active : 1;
1912
    DWORD transform_feedback_paused : 1;
1913
    DWORD shader_update_mask : 6; /* WINED3D_SHADER_TYPE_COUNT, 6 */
1914
    DWORD clip_distance_mask : 8; /* MAX_CLIP_DISTANCES, 8 */
1915 1916
    DWORD num_untracked_materials : 2;  /* Max value 2 */
    DWORD padding : 7;
1917

1918
    DWORD constant_update_mask;
1919
    DWORD numbered_array_mask;
1920
    GLenum                  tracking_parm;     /* Which source is tracking current colour         */
1921
    GLenum                  untracked_materials[2];
1922
    UINT                    blit_w, blit_h;
1923
    enum fogsource          fog_source;
1924
    DWORD active_texture;
1925
    DWORD *texture_type;
1926

1927 1928
    UINT instance_count;

1929
    /* The actual opengl context */
1930
    UINT level;
1931 1932
    HGLRC restore_ctx;
    HDC restore_dc;
1933
    int restore_pf;
1934
    HWND restore_pf_win;
1935 1936 1937
    HGLRC                   glCtx;
    HWND                    win_handle;
    HDC                     hdc;
1938
    int pixel_format;
1939
    GLint                   aux_buffers;
1940

1941
    void *shader_backend_data;
1942
    void *fragment_pipe_data;
1943

1944
    /* FBOs */
1945
    UINT                    fbo_entry_count;
1946
    struct list             fbo_list;
1947
    struct list             fbo_destroy_list;
1948
    struct fbo_entry        *current_fbo;
1949 1950
    GLuint                  fbo_read_binding;
    GLuint                  fbo_draw_binding;
1951
    struct wined3d_rendertarget_info blit_targets[MAX_RENDER_TARGET_VIEWS];
1952
    DWORD draw_buffers_mask; /* Enabled draw buffers, 31 max. */
1953

1954 1955
    /* Queries */
    GLuint *free_occlusion_queries;
1956 1957
    SIZE_T free_occlusion_query_size;
    unsigned int free_occlusion_query_count;
1958 1959
    struct list occlusion_queries;

1960 1961 1962 1963
    union wined3d_gl_fence_object *free_fences;
    SIZE_T free_fence_size;
    unsigned int free_fence_count;
    struct list fences;
1964

1965
    GLuint *free_timestamp_queries;
1966 1967
    SIZE_T free_timestamp_query_size;
    unsigned int free_timestamp_query_count;
1968 1969
    struct list timestamp_queries;

1970 1971 1972 1973 1974
    union wined3d_gl_so_statistics_query *free_so_statistics_queries;
    SIZE_T free_so_statistics_query_size;
    unsigned int free_so_statistics_query_count;
    struct list so_statistics_queries;

1975 1976 1977 1978 1979
    union wined3d_gl_pipeline_statistics_query *free_pipeline_statistics_queries;
    SIZE_T free_pipeline_statistics_query_size;
    unsigned int free_pipeline_statistics_query_count;
    struct list pipeline_statistics_queries;

1980 1981 1982
    struct wined3d_stream_info stream_info;

    /* Fences for GL_APPLE_flush_buffer_range */
1983 1984
    struct wined3d_fence *buffer_fences[MAX_ATTRIBS];
    unsigned int buffer_fence_count;
1985

1986 1987
    GLuint blit_vbo;

1988 1989
    DWORD tex_unit_map[MAX_COMBINED_SAMPLERS];
    DWORD rev_tex_unit_map[MAX_GL_FRAGMENT_SAMPLERS + MAX_VERTEX_SAMPLERS];
1990

1991 1992 1993 1994
    /* Extension emulation */
    GLint                   gl_fog_source;
    GLfloat                 fog_coord_value;
    GLfloat                 color[4], fogstart, fogend, fogcolor[4];
1995
    GLuint                  dummy_arbfp_prog;
1996 1997

    unsigned int viewport_count;
1998
    unsigned int scissor_rect_count;
1999 2000
};

2001 2002
struct wined3d_fb_state
{
2003
    struct wined3d_rendertarget_view *render_targets[MAX_RENDER_TARGET_VIEWS];
2004
    struct wined3d_rendertarget_view *depth_stencil;
2005 2006
};

2007
typedef void (*APPLYSTATEFUNC)(struct wined3d_context *ctx, const struct wined3d_state *state, DWORD state_id);
2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018

struct StateEntry
{
    DWORD representative;
    APPLYSTATEFUNC apply;
};

struct StateEntryTemplate
{
    DWORD state;
    struct StateEntry content;
2019
    enum wined3d_gl_extension extension;
2020 2021
};

2022
#define WINED3D_FRAGMENT_CAP_PROJ_CONTROL   0x00000001
2023
#define WINED3D_FRAGMENT_CAP_SRGB_WRITE     0x00000002
2024
#define WINED3D_FRAGMENT_CAP_COLOR_KEY      0x00000004
2025

2026 2027
struct fragment_caps
{
2028
    DWORD wined3d_caps;
2029 2030 2031 2032 2033 2034
    DWORD PrimitiveMiscCaps;
    DWORD TextureOpCaps;
    DWORD MaxTextureBlendStages;
    DWORD MaxSimultaneousTextures;
};

2035 2036 2037
#define GL_EXT_EMUL_ARB_MULTITEXTURE 0x00000001
#define GL_EXT_EMUL_EXT_FOG_COORD    0x00000002

2038 2039
struct fragment_pipeline
{
2040
    void (*enable_extension)(const struct wined3d_gl_info *gl_info, BOOL enable);
2041
    void (*get_caps)(const struct wined3d_gl_info *gl_info, struct fragment_caps *caps);
2042
    DWORD (*get_emul_mask)(const struct wined3d_gl_info *gl_info);
2043
    void *(*alloc_private)(const struct wined3d_shader_backend_ops *shader_backend, void *shader_priv);
2044
    void (*free_private)(struct wined3d_device *device);
2045 2046
    BOOL (*allocate_context_data)(struct wined3d_context *context);
    void (*free_context_data)(struct wined3d_context *context);
2047 2048 2049 2050
    BOOL (*color_fixup_supported)(struct color_fixup_desc fixup);
    const struct StateEntryTemplate *states;
};

2051 2052
struct wined3d_vertex_caps
{
2053
    BOOL xyzrhw;
2054
    BOOL emulated_flatshading;
2055
    BOOL ffp_generic_attributes;
2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068
    DWORD max_active_lights;
    DWORD max_vertex_blend_matrices;
    DWORD max_vertex_blend_matrix_index;
    DWORD vertex_processing_caps;
    DWORD fvf_caps;
    DWORD max_user_clip_planes;
    DWORD raster_caps;
};

struct wined3d_vertex_pipe_ops
{
    void (*vp_enable)(const struct wined3d_gl_info *gl_info, BOOL enable);
    void (*vp_get_caps)(const struct wined3d_gl_info *gl_info, struct wined3d_vertex_caps *caps);
2069
    DWORD (*vp_get_emul_mask)(const struct wined3d_gl_info *gl_info);
2070 2071 2072 2073 2074
    void *(*vp_alloc)(const struct wined3d_shader_backend_ops *shader_backend, void *shader_priv);
    void (*vp_free)(struct wined3d_device *device);
    const struct StateEntryTemplate *vp_states;
};

2075
extern const struct StateEntryTemplate misc_state_template[] DECLSPEC_HIDDEN;
2076
extern const struct fragment_pipeline none_fragment_pipe DECLSPEC_HIDDEN;
2077 2078 2079 2080 2081
extern const struct fragment_pipeline ffp_fragment_pipeline DECLSPEC_HIDDEN;
extern const struct fragment_pipeline atifs_fragment_pipeline DECLSPEC_HIDDEN;
extern const struct fragment_pipeline arbfp_fragment_pipeline DECLSPEC_HIDDEN;
extern const struct fragment_pipeline nvts_fragment_pipeline DECLSPEC_HIDDEN;
extern const struct fragment_pipeline nvrc_fragment_pipeline DECLSPEC_HIDDEN;
2082
extern const struct fragment_pipeline glsl_fragment_pipe DECLSPEC_HIDDEN;
2083

2084 2085
extern const struct wined3d_vertex_pipe_ops none_vertex_pipe DECLSPEC_HIDDEN;
extern const struct wined3d_vertex_pipe_ops ffp_vertex_pipe DECLSPEC_HIDDEN;
2086
extern const struct wined3d_vertex_pipe_ops glsl_vertex_pipe DECLSPEC_HIDDEN;
2087

2088 2089
/* "Base" state table */
HRESULT compile_state_table(struct StateEntry *StateTable, APPLYSTATEFUNC **dev_multistate_funcs,
2090 2091 2092
        const struct wined3d_gl_info *gl_info, const struct wined3d_d3d_info *d3d_info,
        const struct wined3d_vertex_pipe_ops *vertex, const struct fragment_pipeline *fragment,
        const struct StateEntryTemplate *misc) DECLSPEC_HIDDEN;
2093

2094
enum wined3d_blit_op
2095
{
2096
    WINED3D_BLIT_OP_COLOR_BLIT,
2097
    WINED3D_BLIT_OP_COLOR_BLIT_ALPHATEST,
2098
    WINED3D_BLIT_OP_COLOR_BLIT_CKEY,
2099
    WINED3D_BLIT_OP_COLOR_FILL,
2100
    WINED3D_BLIT_OP_DEPTH_FILL,
2101
    WINED3D_BLIT_OP_DEPTH_BLIT,
2102
    WINED3D_BLIT_OP_RAW_BLIT,
2103 2104
};

2105 2106 2107 2108 2109 2110
struct wined3d_blitter
{
    const struct wined3d_blitter_ops *ops;
    struct wined3d_blitter *next;
};

2111
struct wined3d_blitter_ops
2112
{
2113 2114
    void (*blitter_destroy)(struct wined3d_blitter *blitter, struct wined3d_context *context);
    void (*blitter_clear)(struct wined3d_blitter *blitter, struct wined3d_device *device,
2115
            unsigned int rt_count, const struct wined3d_fb_state *fb, unsigned int rect_count, const RECT *clear_rects,
2116
            const RECT *draw_rect, DWORD flags, const struct wined3d_color *colour, float depth, DWORD stencil);
2117
    DWORD (*blitter_blit)(struct wined3d_blitter *blitter, enum wined3d_blit_op op, struct wined3d_context *context,
2118 2119 2120 2121
            struct wined3d_texture *src_texture, unsigned int src_sub_resource_idx, DWORD src_location,
            const RECT *src_rect, struct wined3d_texture *dst_texture, unsigned int dst_sub_resource_idx,
            DWORD dst_location, const RECT *dst_rect, const struct wined3d_color_key *colour_key,
            enum wined3d_texture_filter_type filter);
2122 2123
};

2124 2125 2126 2127 2128 2129 2130
void wined3d_arbfp_blitter_create(struct wined3d_blitter **next,
        const struct wined3d_device *device) DECLSPEC_HIDDEN;
struct wined3d_blitter *wined3d_cpu_blitter_create(void) DECLSPEC_HIDDEN;
void wined3d_fbo_blitter_create(struct wined3d_blitter **next,
        const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
void wined3d_ffp_blitter_create(struct wined3d_blitter **next,
        const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
2131
struct wined3d_blitter *wined3d_glsl_blitter_create(struct wined3d_blitter **next,
2132
        const struct wined3d_device *device) DECLSPEC_HIDDEN;
2133 2134
void wined3d_raw_blitter_create(struct wined3d_blitter **next,
        const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
2135

2136
BOOL wined3d_clip_blit(const RECT *clip_rect, RECT *clipped, RECT *other) DECLSPEC_HIDDEN;
2137

2138
struct wined3d_context *context_acquire(const struct wined3d_device *device,
2139
        struct wined3d_texture *texture, unsigned int sub_resource_idx) DECLSPEC_HIDDEN;
2140
void context_alloc_fence(struct wined3d_context *context, struct wined3d_fence *fence) DECLSPEC_HIDDEN;
2141 2142
void context_alloc_occlusion_query(struct wined3d_context *context,
        struct wined3d_occlusion_query *query) DECLSPEC_HIDDEN;
2143
void context_apply_blit_state(struct wined3d_context *context, const struct wined3d_device *device) DECLSPEC_HIDDEN;
2144
BOOL context_apply_clear_state(struct wined3d_context *context, const struct wined3d_state *state,
2145
        UINT rt_count, const struct wined3d_fb_state *fb) DECLSPEC_HIDDEN;
2146
void context_apply_fbo_state_blit(struct wined3d_context *context, GLenum target,
2147 2148
        struct wined3d_resource *rt, unsigned int rt_sub_resource_idx,
        struct wined3d_resource *ds, unsigned int ds_sub_resource_idx, DWORD location) DECLSPEC_HIDDEN;
2149 2150
void context_apply_ffp_blit_state(struct wined3d_context *context,
        const struct wined3d_device *device) DECLSPEC_HIDDEN;
2151 2152
void context_active_texture(struct wined3d_context *context, const struct wined3d_gl_info *gl_info,
        unsigned int unit) DECLSPEC_HIDDEN;
2153
void context_bind_bo(struct wined3d_context *context, GLenum binding, GLuint name) DECLSPEC_HIDDEN;
2154 2155
void context_bind_dummy_textures(const struct wined3d_device *device,
        const struct wined3d_context *context) DECLSPEC_HIDDEN;
2156
void context_bind_texture(struct wined3d_context *context, GLenum target, GLuint name) DECLSPEC_HIDDEN;
2157
void context_check_fbo_status(const struct wined3d_context *context, GLenum target) DECLSPEC_HIDDEN;
2158 2159 2160
void context_copy_bo_address(struct wined3d_context *context,
        const struct wined3d_bo_address *dst, GLenum dst_binding,
        const struct wined3d_bo_address *src, GLenum src_binding, size_t size) DECLSPEC_HIDDEN;
2161
struct wined3d_context *context_create(struct wined3d_swapchain *swapchain, struct wined3d_texture *target,
2162
        const struct wined3d_format *ds_format) DECLSPEC_HIDDEN;
2163
HGLRC context_create_wgl_attribs(const struct wined3d_gl_info *gl_info, HDC hdc, HGLRC share_ctx) DECLSPEC_HIDDEN;
2164
void context_destroy(struct wined3d_device *device, struct wined3d_context *context) DECLSPEC_HIDDEN;
2165 2166 2167
void context_draw_shaded_quad(struct wined3d_context *context, struct wined3d_texture *texture,
        unsigned int sub_resource_idx, const RECT *src_rect, const RECT *dst_rect,
        enum wined3d_texture_filter_type filter) DECLSPEC_HIDDEN;
2168 2169 2170
void context_draw_textured_quad(struct wined3d_context *context, struct wined3d_texture *texture,
        unsigned int sub_resource_idx, const RECT *src_rect, const RECT *dst_rect,
        enum wined3d_texture_filter_type filter) DECLSPEC_HIDDEN;
2171
void context_enable_clip_distances(struct wined3d_context *context, unsigned int mask) DECLSPEC_HIDDEN;
2172
void context_end_transform_feedback(struct wined3d_context *context) DECLSPEC_HIDDEN;
2173
void context_free_fence(struct wined3d_fence *fence) DECLSPEC_HIDDEN;
2174 2175
void context_free_occlusion_query(struct wined3d_occlusion_query *query) DECLSPEC_HIDDEN;
struct wined3d_context *context_get_current(void) DECLSPEC_HIDDEN;
2176
GLenum context_get_offscreen_gl_buffer(const struct wined3d_context *context) DECLSPEC_HIDDEN;
2177 2178
const DWORD *context_get_tex_unit_mapping(const struct wined3d_context *context,
        const struct wined3d_shader_version *shader_version, unsigned int *base, unsigned int *count) DECLSPEC_HIDDEN;
2179
DWORD context_get_tls_idx(void) DECLSPEC_HIDDEN;
2180 2181
void context_gl_resource_released(struct wined3d_device *device,
        GLuint name, BOOL rb_namespace) DECLSPEC_HIDDEN;
2182
void context_invalidate_compute_state(struct wined3d_context *context, DWORD state_id) DECLSPEC_HIDDEN;
2183
void context_invalidate_state(struct wined3d_context *context, DWORD state_id) DECLSPEC_HIDDEN;
2184 2185
void context_load_tex_coords(const struct wined3d_context *context, const struct wined3d_stream_info *si,
        GLuint *current_bo, const struct wined3d_state *state) DECLSPEC_HIDDEN;
2186 2187
void *context_map_bo_address(struct wined3d_context *context, const struct wined3d_bo_address *data,
        size_t size, GLenum binding, DWORD flags) DECLSPEC_HIDDEN;
2188 2189
struct wined3d_context *context_reacquire(const struct wined3d_device *device,
        struct wined3d_context *context) DECLSPEC_HIDDEN;
2190
void context_release(struct wined3d_context *context) DECLSPEC_HIDDEN;
2191
void context_resource_released(const struct wined3d_device *device, struct wined3d_resource *resource) DECLSPEC_HIDDEN;
2192 2193
void context_restore(struct wined3d_context *context, struct wined3d_texture *texture,
        unsigned int sub_resource_idx) DECLSPEC_HIDDEN;
2194
BOOL context_set_current(struct wined3d_context *ctx) DECLSPEC_HIDDEN;
2195
void context_set_draw_buffer(struct wined3d_context *context, GLenum buffer) DECLSPEC_HIDDEN;
2196
void context_set_tls_idx(DWORD idx) DECLSPEC_HIDDEN;
2197 2198 2199 2200
void context_state_drawbuf(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
void context_state_fb(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
2201
void context_texture_update(struct wined3d_context *context, const struct wined3d_texture *texture) DECLSPEC_HIDDEN;
2202
void context_unload_tex_coords(const struct wined3d_context *context) DECLSPEC_HIDDEN;
2203 2204
void context_unmap_bo_address(struct wined3d_context *context,
        const struct wined3d_bo_address *data, GLenum binding) DECLSPEC_HIDDEN;
2205 2206
void context_update_stream_sources(struct wined3d_context *context,
        const struct wined3d_state *state) DECLSPEC_HIDDEN;
2207

2208 2209 2210
/*****************************************************************************
 * Internal representation of a light
 */
2211 2212
struct wined3d_light_info
{
2213
    struct wined3d_light OriginalParms; /* Note D3D8LIGHT == D3D9LIGHT */
2214 2215
    DWORD        OriginalIndex;
    LONG         glIndex;
2216
    BOOL         enabled;
2217 2218

    /* Converted parms to speed up swapping lights */
2219 2220 2221 2222
    struct wined3d_vec4 position;
    struct wined3d_vec4 direction;
    float exponent;
    float cutoff;
2223

2224
    struct list entry;
2225 2226
};

2227
/* The default light parameters */
2228
extern const struct wined3d_light WINED3D_default_light DECLSPEC_HIDDEN;
2229

2230
struct wined3d_pixel_format
2231 2232
{
    int iPixelFormat; /* WGL pixel format */
2233
    int iPixelType; /* WGL pixel type e.g. WGL_TYPE_RGBA_ARB, WGL_TYPE_RGBA_FLOAT_ARB or WGL_TYPE_COLORINDEX_ARB */
2234
    int redSize, greenSize, blueSize, alphaSize, colorSize;
2235
    int depthSize, stencilSize;
2236
    BOOL windowDrawable;
2237 2238
    BOOL doubleBuffer;
    int auxBuffers;
2239
    int numSamples;
2240
};
2241

2242 2243
enum wined3d_pci_vendor
{
2244 2245 2246 2247 2248
    HW_VENDOR_SOFTWARE              = 0x0000,
    HW_VENDOR_AMD                   = 0x1002,
    HW_VENDOR_NVIDIA                = 0x10de,
    HW_VENDOR_VMWARE                = 0x15ad,
    HW_VENDOR_INTEL                 = 0x8086,
2249 2250 2251 2252 2253 2254
};

enum wined3d_pci_device
{
    CARD_WINE                       = 0x0000,

2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265
    CARD_AMD_RAGE_128PRO            = 0x5246,
    CARD_AMD_RADEON_7200            = 0x5144,
    CARD_AMD_RADEON_8500            = 0x514c,
    CARD_AMD_RADEON_9500            = 0x4144,
    CARD_AMD_RADEON_XPRESS_200M     = 0x5955,
    CARD_AMD_RADEON_X700            = 0x5e4c,
    CARD_AMD_RADEON_X1600           = 0x71c2,
    CARD_AMD_RADEON_HD2350          = 0x94c7,
    CARD_AMD_RADEON_HD2600          = 0x9581,
    CARD_AMD_RADEON_HD2900          = 0x9400,
    CARD_AMD_RADEON_HD3200          = 0x9620,
2266
    CARD_AMD_RADEON_HD3850          = 0x9515,
2267
    CARD_AMD_RADEON_HD4200M         = 0x9712,
2268 2269 2270
    CARD_AMD_RADEON_HD4350          = 0x954f,
    CARD_AMD_RADEON_HD4600          = 0x9495,
    CARD_AMD_RADEON_HD4700          = 0x944e,
2271
    CARD_AMD_RADEON_HD4800          = 0x944c,
2272 2273
    CARD_AMD_RADEON_HD5400          = 0x68f9,
    CARD_AMD_RADEON_HD5600          = 0x68d8,
2274 2275
    CARD_AMD_RADEON_HD5700          = 0x68be,
    CARD_AMD_RADEON_HD5800          = 0x6898,
2276
    CARD_AMD_RADEON_HD5900          = 0x689c,
2277 2278
    CARD_AMD_RADEON_HD6300          = 0x9803,
    CARD_AMD_RADEON_HD6400          = 0x6770,
2279
    CARD_AMD_RADEON_HD6410D         = 0x9644,
2280
    CARD_AMD_RADEON_HD6480G         = 0x9648,
2281
    CARD_AMD_RADEON_HD6550D         = 0x9640,
2282
    CARD_AMD_RADEON_HD6600          = 0x6758,
2283
    CARD_AMD_RADEON_HD6600M         = 0x6741,
2284
    CARD_AMD_RADEON_HD6700          = 0x68ba,
2285 2286
    CARD_AMD_RADEON_HD6800          = 0x6739,
    CARD_AMD_RADEON_HD6900          = 0x6719,
2287
    CARD_AMD_RADEON_HD7660D         = 0x9901,
2288 2289
    CARD_AMD_RADEON_HD7700          = 0x683d,
    CARD_AMD_RADEON_HD7800          = 0x6819,
2290
    CARD_AMD_RADEON_HD7900          = 0x679a,
2291 2292 2293 2294 2295
    CARD_AMD_RADEON_HD8600M         = 0x6660,
    CARD_AMD_RADEON_HD8670          = 0x6610,
    CARD_AMD_RADEON_HD8770          = 0x665c,
    CARD_AMD_RADEON_R3              = 0x9830,
    CARD_AMD_RADEON_R7              = 0x130f,
2296 2297
    CARD_AMD_RADEON_R9_285          = 0x6939,
    CARD_AMD_RADEON_R9_290          = 0x67b1,
2298
    CARD_AMD_RADEON_R9_FURY         = 0x7300,
2299 2300
    CARD_AMD_RADEON_RX_460          = 0x67ef,
    CARD_AMD_RADEON_RX_480          = 0x67df,
2301
    CARD_AMD_RADEON_RX_VEGA         = 0x687f,
2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318

    CARD_NVIDIA_RIVA_128            = 0x0018,
    CARD_NVIDIA_RIVA_TNT            = 0x0020,
    CARD_NVIDIA_RIVA_TNT2           = 0x0028,
    CARD_NVIDIA_GEFORCE             = 0x0100,
    CARD_NVIDIA_GEFORCE2_MX         = 0x0110,
    CARD_NVIDIA_GEFORCE2            = 0x0150,
    CARD_NVIDIA_GEFORCE3            = 0x0200,
    CARD_NVIDIA_GEFORCE4_MX         = 0x0170,
    CARD_NVIDIA_GEFORCE4_TI4200     = 0x0253,
    CARD_NVIDIA_GEFORCEFX_5200      = 0x0320,
    CARD_NVIDIA_GEFORCEFX_5600      = 0x0312,
    CARD_NVIDIA_GEFORCEFX_5800      = 0x0302,
    CARD_NVIDIA_GEFORCE_6200        = 0x014f,
    CARD_NVIDIA_GEFORCE_6600GT      = 0x0140,
    CARD_NVIDIA_GEFORCE_6800        = 0x0041,
    CARD_NVIDIA_GEFORCE_7300        = 0x01d7, /* GeForce Go 7300 */
2319
    CARD_NVIDIA_GEFORCE_7400        = 0x01d8,
2320 2321
    CARD_NVIDIA_GEFORCE_7600        = 0x0391,
    CARD_NVIDIA_GEFORCE_7800GT      = 0x0092,
2322
    CARD_NVIDIA_GEFORCE_8200        = 0x0849, /* Other PCI ID 0x084b */
2323
    CARD_NVIDIA_GEFORCE_8300GS      = 0x0423,
2324 2325
    CARD_NVIDIA_GEFORCE_8400GS      = 0x0404,
    CARD_NVIDIA_GEFORCE_8500GT      = 0x0421,
2326 2327 2328
    CARD_NVIDIA_GEFORCE_8600GT      = 0x0402,
    CARD_NVIDIA_GEFORCE_8600MGT     = 0x0407,
    CARD_NVIDIA_GEFORCE_8800GTS     = 0x0193,
2329
    CARD_NVIDIA_GEFORCE_8800GTX     = 0x0191,
2330
    CARD_NVIDIA_GEFORCE_9200        = 0x086d,
2331
    CARD_NVIDIA_GEFORCE_9300        = 0x086c,
2332
    CARD_NVIDIA_GEFORCE_9400M       = 0x0863,
2333 2334 2335
    CARD_NVIDIA_GEFORCE_9400GT      = 0x042c,
    CARD_NVIDIA_GEFORCE_9500GT      = 0x0640,
    CARD_NVIDIA_GEFORCE_9600GT      = 0x0622,
2336
    CARD_NVIDIA_GEFORCE_9700MGT     = 0x064a,
2337
    CARD_NVIDIA_GEFORCE_9800GT      = 0x0614,
2338 2339 2340
    CARD_NVIDIA_GEFORCE_210         = 0x0a23,
    CARD_NVIDIA_GEFORCE_GT220       = 0x0a20,
    CARD_NVIDIA_GEFORCE_GT240       = 0x0ca3,
2341
    CARD_NVIDIA_GEFORCE_GTS250      = 0x0615,
2342 2343 2344
    CARD_NVIDIA_GEFORCE_GTX260      = 0x05e2,
    CARD_NVIDIA_GEFORCE_GTX275      = 0x05e6,
    CARD_NVIDIA_GEFORCE_GTX280      = 0x05e1,
2345
    CARD_NVIDIA_GEFORCE_315M        = 0x0a7a,
2346
    CARD_NVIDIA_GEFORCE_320M        = 0x08a3,
2347
    CARD_NVIDIA_GEFORCE_GT320M      = 0x0a2d,
2348
    CARD_NVIDIA_GEFORCE_GT325M      = 0x0a35,
2349
    CARD_NVIDIA_GEFORCE_GT330       = 0x0ca0,
2350
    CARD_NVIDIA_GEFORCE_GTS350M     = 0x0cb0,
2351
    CARD_NVIDIA_GEFORCE_410M        = 0x1055,
2352
    CARD_NVIDIA_GEFORCE_GT420       = 0x0de2,
2353
    CARD_NVIDIA_GEFORCE_GT425M      = 0x0df0,
2354 2355 2356
    CARD_NVIDIA_GEFORCE_GT430       = 0x0de1,
    CARD_NVIDIA_GEFORCE_GT440       = 0x0de0,
    CARD_NVIDIA_GEFORCE_GTS450      = 0x0dc4,
2357
    CARD_NVIDIA_GEFORCE_GTX460      = 0x0e22,
2358
    CARD_NVIDIA_GEFORCE_GTX460M     = 0x0dd1,
2359
    CARD_NVIDIA_GEFORCE_GTX465      = 0x06c4,
2360 2361
    CARD_NVIDIA_GEFORCE_GTX470      = 0x06cd,
    CARD_NVIDIA_GEFORCE_GTX480      = 0x06c0,
2362
    CARD_NVIDIA_GEFORCE_GT520       = 0x1040,
2363
    CARD_NVIDIA_GEFORCE_GT525M      = 0x0dec,
2364
    CARD_NVIDIA_GEFORCE_GT540M      = 0x0df4,
2365
    CARD_NVIDIA_GEFORCE_GTX550      = 0x1244,
2366
    CARD_NVIDIA_GEFORCE_GT555M      = 0x04b8,
2367
    CARD_NVIDIA_GEFORCE_GTX560TI    = 0x1200,
2368
    CARD_NVIDIA_GEFORCE_GTX560M     = 0x1251,
2369
    CARD_NVIDIA_GEFORCE_GTX560      = 0x1201,
2370 2371
    CARD_NVIDIA_GEFORCE_GTX570      = 0x1081,
    CARD_NVIDIA_GEFORCE_GTX580      = 0x1080,
2372
    CARD_NVIDIA_GEFORCE_GT610       = 0x104a,
2373
    CARD_NVIDIA_GEFORCE_GT630       = 0x0f00,
2374
    CARD_NVIDIA_GEFORCE_GT630M      = 0x0de9,
2375
    CARD_NVIDIA_GEFORCE_GT640M      = 0x0fd2,
2376
    CARD_NVIDIA_GEFORCE_GT650M      = 0x0fd1,
2377 2378 2379
    CARD_NVIDIA_GEFORCE_GTX650      = 0x0fc6,
    CARD_NVIDIA_GEFORCE_GTX650TI    = 0x11c6,
    CARD_NVIDIA_GEFORCE_GTX660      = 0x11c0,
2380
    CARD_NVIDIA_GEFORCE_GTX660M     = 0x0fd4,
2381
    CARD_NVIDIA_GEFORCE_GTX660TI    = 0x1183,
2382
    CARD_NVIDIA_GEFORCE_GTX670      = 0x1189,
2383
    CARD_NVIDIA_GEFORCE_GTX670MX    = 0x11a1,
2384
    CARD_NVIDIA_GEFORCE_GTX675MX    = 0x11a7,
2385
    CARD_NVIDIA_GEFORCE_GTX680      = 0x1180,
2386
    CARD_NVIDIA_GEFORCE_GTX690      = 0x1188,
2387
    CARD_NVIDIA_GEFORCE_GT730       = 0x1287,
2388
    CARD_NVIDIA_GEFORCE_GT730M      = 0x0fe1,
2389
    CARD_NVIDIA_GEFORCE_GT740M      = 0x1292,
2390
    CARD_NVIDIA_GEFORCE_GT750M      = 0x0fe9,
2391 2392
    CARD_NVIDIA_GEFORCE_GTX750      = 0x1381,
    CARD_NVIDIA_GEFORCE_GTX750TI    = 0x1380,
2393
    CARD_NVIDIA_GEFORCE_GTX760      = 0x1187,
2394
    CARD_NVIDIA_GEFORCE_GTX760TI    = 0x1193,
2395
    CARD_NVIDIA_GEFORCE_GTX765M     = 0x11e2,
2396
    CARD_NVIDIA_GEFORCE_GTX770M     = 0x11e0,
2397
    CARD_NVIDIA_GEFORCE_GTX770      = 0x1184,
2398
    CARD_NVIDIA_GEFORCE_GTX780      = 0x1004,
2399
    CARD_NVIDIA_GEFORCE_GTX780TI    = 0x100a,
2400 2401 2402 2403
    CARD_NVIDIA_GEFORCE_GTXTITAN    = 0x1005,
    CARD_NVIDIA_GEFORCE_GTXTITANB   = 0x100c,
    CARD_NVIDIA_GEFORCE_GTXTITANX   = 0x17c2,
    CARD_NVIDIA_GEFORCE_GTXTITANZ   = 0x1001,
2404
    CARD_NVIDIA_GEFORCE_820M        = 0x0fed,
2405
    CARD_NVIDIA_GEFORCE_830M        = 0x1340,
2406
    CARD_NVIDIA_GEFORCE_840M        = 0x1341,
2407
    CARD_NVIDIA_GEFORCE_845M        = 0x1344,
2408
    CARD_NVIDIA_GEFORCE_GTX850M     = 0x1391,
2409
    CARD_NVIDIA_GEFORCE_GTX860M     = 0x1392, /* Other PCI ID 0x119a */
2410
    CARD_NVIDIA_GEFORCE_GTX870M     = 0x1199,
2411
    CARD_NVIDIA_GEFORCE_GTX880M     = 0x1198,
2412
    CARD_NVIDIA_GEFORCE_940M        = 0x1347,
2413 2414 2415
    CARD_NVIDIA_GEFORCE_GTX950      = 0x1402,
    CARD_NVIDIA_GEFORCE_GTX950M     = 0x139a,
    CARD_NVIDIA_GEFORCE_GTX960      = 0x1401,
2416
    CARD_NVIDIA_GEFORCE_GTX960M     = 0x139b,
2417
    CARD_NVIDIA_GEFORCE_GTX970      = 0x13c2,
2418
    CARD_NVIDIA_GEFORCE_GTX970M     = 0x13d8,
2419
    CARD_NVIDIA_GEFORCE_GTX980      = 0x13c0,
2420
    CARD_NVIDIA_GEFORCE_GTX980TI    = 0x17c8,
2421
    CARD_NVIDIA_GEFORCE_GTX1050     = 0x1c81,
2422
    CARD_NVIDIA_GEFORCE_GTX1050TI   = 0x1c82,
2423 2424 2425
    CARD_NVIDIA_GEFORCE_GTX1060     = 0x1c03,
    CARD_NVIDIA_GEFORCE_GTX1070     = 0x1b81,
    CARD_NVIDIA_GEFORCE_GTX1080     = 0x1b80,
2426
    CARD_NVIDIA_GEFORCE_GTX1080TI   = 0x1b06,
2427
    CARD_NVIDIA_TITANX_PASCAL       = 0x1b00,
2428
    CARD_NVIDIA_TITANV              = 0x1d81,
2429

2430 2431
    CARD_VMWARE_SVGA3D              = 0x0405,

2432 2433
    CARD_INTEL_830M                 = 0x3577,
    CARD_INTEL_855GM                = 0x3582,
2434
    CARD_INTEL_845G                 = 0x2562,
2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451
    CARD_INTEL_865G                 = 0x2572,
    CARD_INTEL_915G                 = 0x2582,
    CARD_INTEL_E7221G               = 0x258a,
    CARD_INTEL_915GM                = 0x2592,
    CARD_INTEL_945G                 = 0x2772,
    CARD_INTEL_945GM                = 0x27a2,
    CARD_INTEL_945GME               = 0x27ae,
    CARD_INTEL_Q35                  = 0x29b2,
    CARD_INTEL_G33                  = 0x29c2,
    CARD_INTEL_Q33                  = 0x29d2,
    CARD_INTEL_PNVG                 = 0xa001,
    CARD_INTEL_PNVM                 = 0xa011,
    CARD_INTEL_965Q                 = 0x2992,
    CARD_INTEL_965G                 = 0x2982,
    CARD_INTEL_946GZ                = 0x2972,
    CARD_INTEL_965GM                = 0x2a02,
    CARD_INTEL_965GME               = 0x2a12,
2452
    CARD_INTEL_GM45                 = 0x2a42,
2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465
    CARD_INTEL_IGD                  = 0x2e02,
    CARD_INTEL_Q45                  = 0x2e12,
    CARD_INTEL_G45                  = 0x2e22,
    CARD_INTEL_G41                  = 0x2e32,
    CARD_INTEL_B43                  = 0x2e92,
    CARD_INTEL_ILKD                 = 0x0042,
    CARD_INTEL_ILKM                 = 0x0046,
    CARD_INTEL_SNBD                 = 0x0122,
    CARD_INTEL_SNBM                 = 0x0126,
    CARD_INTEL_SNBS                 = 0x010a,
    CARD_INTEL_IVBD                 = 0x0162,
    CARD_INTEL_IVBM                 = 0x0166,
    CARD_INTEL_IVBS                 = 0x015a,
2466
    CARD_INTEL_HWD                  = 0x0412,
2467
    CARD_INTEL_HWM                  = 0x0416,
2468
    CARD_INTEL_HD5000               = 0x0a26,
2469 2470 2471 2472 2473 2474 2475 2476 2477
    CARD_INTEL_I5100_1              = 0x0a22,
    CARD_INTEL_I5100_2              = 0x0a2a,
    CARD_INTEL_I5100_3              = 0x0a2b,
    CARD_INTEL_I5100_4              = 0x0a2e,
    CARD_INTEL_IP5200_1             = 0x0d22,
    CARD_INTEL_IP5200_2             = 0x0d26,
    CARD_INTEL_IP5200_3             = 0x0d2a,
    CARD_INTEL_IP5200_4             = 0x0d2b,
    CARD_INTEL_IP5200_5             = 0x0d2e,
2478 2479 2480 2481 2482
    CARD_INTEL_HD5300               = 0x161e,
    CARD_INTEL_HD5500               = 0x1616,
    CARD_INTEL_HD5600               = 0x1612,
    CARD_INTEL_HD6000               = 0x1626,
    CARD_INTEL_I6100                = 0x162b,
2483
    CARD_INTEL_IP6200               = 0x1622,
2484
    CARD_INTEL_IPP6300              = 0x162a,
2485 2486 2487 2488 2489 2490
    CARD_INTEL_HD510_1              = 0x1902,
    CARD_INTEL_HD510_2              = 0x1906,
    CARD_INTEL_HD510_3              = 0x190b,
    CARD_INTEL_HD515                = 0x191e,
    CARD_INTEL_HD520_1              = 0x1916,
    CARD_INTEL_HD520_2              = 0x1921,
2491 2492
    CARD_INTEL_HD530_1              = 0x1912,
    CARD_INTEL_HD530_2              = 0x191b,
2493 2494 2495 2496 2497 2498 2499 2500 2501
    CARD_INTEL_HDP530               = 0x191d,
    CARD_INTEL_I540                 = 0x1926,
    CARD_INTEL_I550                 = 0x1927,
    CARD_INTEL_I555                 = 0x192b,
    CARD_INTEL_IP555                = 0x192d,
    CARD_INTEL_IP580_1              = 0x1932,
    CARD_INTEL_IP580_2              = 0x193b,
    CARD_INTEL_IPP580_1             = 0x193a,
    CARD_INTEL_IPP580_2             = 0x193d,
2502
    CARD_INTEL_HD630                = 0x5912,
2503 2504
};

2505 2506
struct wined3d_fbo_ops
{
2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520
    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);
2521 2522
    void (WINE_GLAPI *glFramebufferTexture)(GLenum target, GLenum attachment,
            GLuint texture, GLint level);
2523 2524 2525 2526 2527 2528
    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);
2529 2530
    void (WINE_GLAPI *glFramebufferTextureLayer)(GLenum target, GLenum attachment,
            GLuint texture, GLint level, GLint layer);
2531 2532 2533 2534 2535 2536 2537
    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);
2538 2539 2540 2541 2542 2543 2544
};

struct wined3d_gl_limits
{
    UINT buffers;
    UINT lights;
    UINT textures;
2545
    UINT texture_coords;
2546
    unsigned int uniform_blocks[WINED3D_SHADER_TYPE_COUNT];
2547
    unsigned int samplers[WINED3D_SHADER_TYPE_COUNT];
2548 2549
    unsigned int graphics_samplers;
    unsigned int combined_samplers;
2550
    UINT general_combiners;
2551
    UINT user_clip_distances;
2552 2553 2554 2555 2556 2557
    UINT texture_size;
    UINT texture3d_size;
    float pointsize_max;
    float pointsize_min;
    UINT anisotropy;
    float shininess;
2558
    UINT samples;
2559
    UINT vertex_attribs;
2560

2561 2562
    unsigned int texture_buffer_offset_alignment;

2563 2564 2565
    unsigned int framebuffer_width;
    unsigned int framebuffer_height;

2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580
    UINT glsl_varyings;
    UINT glsl_vs_float_constants;
    UINT glsl_ps_float_constants;

    UINT arb_vs_float_constants;
    UINT arb_vs_native_constants;
    UINT arb_vs_instructions;
    UINT arb_vs_temps;
    UINT arb_ps_float_constants;
    UINT arb_ps_local_constants;
    UINT arb_ps_native_constants;
    UINT arb_ps_instructions;
    UINT arb_ps_temps;
};

2581 2582
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) DECLSPEC_HIDDEN;
2583 2584 2585
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) DECLSPEC_HIDDEN;

2586 2587
struct wined3d_gl_info
{
2588
    DWORD selected_gl_version;
2589
    DWORD glsl_version;
2590
    struct wined3d_gl_limits limits;
2591
    DWORD reserved_glsl_constants, reserved_arb_constants;
2592 2593
    DWORD quirks;
    BOOL supported[WINED3D_GL_EXT_COUNT];
2594
    GLint wrap_lookup[WINED3D_TADDRESS_MIRROR_ONCE - WINED3D_TADDRESS_WRAP + 1];
2595

2596
    HGLRC (WINAPI *p_wglCreateContextAttribsARB)(HDC dc, HGLRC share, const GLint *attribs);
2597
    struct opengl_funcs gl_ops;
2598 2599
    struct wined3d_fbo_ops fbo_ops;

2600
    struct wined3d_format *formats;
2601
    unsigned int format_count;
2602 2603
};

2604 2605
struct wined3d_driver_info
{
2606 2607
    enum wined3d_pci_vendor vendor;
    enum wined3d_pci_device device;
2608 2609
    const char *name;
    const char *description;
2610
    UINT64 vram_bytes;
2611 2612 2613 2614
    DWORD version_high;
    DWORD version_low;
};

2615
/* The adapter structure */
2616
struct wined3d_adapter
2617
{
2618
    UINT ordinal;
2619
    POINT monitor_position;
2620 2621
    enum wined3d_format_id screen_format;

2622
    struct wined3d_gl_info  gl_info;
2623
    struct wined3d_d3d_info d3d_info;
2624
    struct wined3d_driver_info driver_info;
2625
    WCHAR                   DeviceName[CCHDEVICENAME]; /* DeviceName for use with e.g. ChangeDisplaySettings */
2626
    unsigned int cfg_count;
2627
    struct wined3d_pixel_format *cfgs;
2628 2629
    UINT64 vram_bytes;
    UINT64 vram_bytes_used;
2630
    LUID luid;
2631

2632
    const struct wined3d_vertex_pipe_ops *vertex_pipe;
2633
    const struct fragment_pipeline *fragment_pipe;
2634
    const struct wined3d_shader_backend_ops *shader_backend;
2635 2636
};

2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651
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;
};

BOOL wined3d_adapter_init_format_info(struct wined3d_adapter *adapter,
        struct wined3d_caps_gl_ctx *ctx) DECLSPEC_HIDDEN;
2652
UINT64 adapter_adjust_memory(struct wined3d_adapter *adapter, INT64 amount) DECLSPEC_HIDDEN;
2653

2654 2655
BOOL wined3d_caps_gl_ctx_test_viewport_subpixel_bits(struct wined3d_caps_gl_ctx *ctx) DECLSPEC_HIDDEN;

2656
void install_gl_compat_wrapper(struct wined3d_gl_info *gl_info, enum wined3d_gl_extension ext) DECLSPEC_HIDDEN;
2657

2658
enum wined3d_projection_type
2659
{
2660 2661 2662
    WINED3D_PROJECTION_NONE    = 0,
    WINED3D_PROJECTION_COUNT3  = 1,
    WINED3D_PROJECTION_COUNT4  = 2
2663 2664
};

2665 2666 2667
/*****************************************************************************
 * Fixed function pipeline replacements
 */
2668
#define ARG_UNUSED          0xff
2669 2670
struct texture_stage_op
{
2671 2672 2673 2674 2675 2676 2677 2678 2679 2680
    unsigned                cop : 8;
    unsigned                carg1 : 8;
    unsigned                carg2 : 8;
    unsigned                carg0 : 8;

    unsigned                aop : 8;
    unsigned                aarg1 : 8;
    unsigned                aarg2 : 8;
    unsigned                aarg0 : 8;

2681
    struct color_fixup_desc color_fixup;
2682
    unsigned                tex_type : 3;
2683
    unsigned                tmp_dst : 1;
2684
    unsigned                projected : 2;
2685
    unsigned                padding : 10;
2686 2687
};

2688 2689 2690 2691
struct ffp_frag_settings
{
    struct texture_stage_op op[MAX_TEXTURES];
    enum wined3d_ffp_ps_fog_mode fog;
2692 2693
    unsigned char sRGB_write;
    unsigned char emul_clipplanes;
2694 2695 2696
    unsigned char texcoords_initialized;
    unsigned char color_key_enabled : 1;
    unsigned char pointsprite : 1;
2697
    unsigned char flatshading : 1;
2698 2699
    unsigned char alpha_test_func : 3;
    unsigned char padding : 2;
2700 2701
};

2702
struct ffp_frag_desc
2703
{
2704
    struct wine_rb_entry entry;
2705
    struct ffp_frag_settings    settings;
2706 2707
};

2708 2709 2710
int wined3d_ffp_frag_program_key_compare(const void *key, const struct wine_rb_entry *entry) DECLSPEC_HIDDEN;
int wined3d_ffp_vertex_program_key_compare(const void *key, const struct wine_rb_entry *entry) DECLSPEC_HIDDEN;

2711
extern const struct wined3d_parent_ops wined3d_null_parent_ops DECLSPEC_HIDDEN;
2712

2713
unsigned int wined3d_max_compat_varyings(const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
2714
void gen_ffp_frag_op(const struct wined3d_context *context, const struct wined3d_state *state,
2715
        struct ffp_frag_settings *settings, BOOL ignore_textype) DECLSPEC_HIDDEN;
2716
const struct ffp_frag_desc *find_ffp_frag_shader(const struct wine_rb_tree *fragment_shaders,
2717 2718
        const struct ffp_frag_settings *settings) DECLSPEC_HIDDEN;
void add_ffp_frag_shader(struct wine_rb_tree *shaders, struct ffp_frag_desc *desc) DECLSPEC_HIDDEN;
2719 2720 2721 2722
void wined3d_ftoa(float value, char *s) DECLSPEC_HIDDEN;

extern const float wined3d_srgb_const0[] DECLSPEC_HIDDEN;
extern const float wined3d_srgb_const1[] DECLSPEC_HIDDEN;
2723

2724 2725 2726 2727 2728 2729 2730 2731 2732
enum wined3d_ffp_vs_fog_mode
{
    WINED3D_FFP_VS_FOG_OFF      = 0,
    WINED3D_FFP_VS_FOG_FOGCOORD = 1,
    WINED3D_FFP_VS_FOG_DEPTH    = 2,
    WINED3D_FFP_VS_FOG_RANGE    = 3,
};

#define WINED3D_FFP_TCI_SHIFT               16
2733
#define WINED3D_FFP_TCI_MASK                0xffu
2734 2735

#define WINED3D_FFP_LIGHT_TYPE_SHIFT(idx)   (3 * (idx))
2736
#define WINED3D_FFP_LIGHT_TYPE_MASK         0x7u
2737 2738 2739

struct wined3d_ffp_vs_settings
{
2740 2741 2742 2743
    DWORD point_light_count          : 4;
    DWORD spot_light_count           : 4;
    DWORD directional_light_count    : 4;
    DWORD parallel_point_light_count : 4;
2744
    DWORD diffuse_source  : 2;
2745
    DWORD emissive_source : 2;
2746 2747
    DWORD ambient_source  : 2;
    DWORD specular_source : 2;
2748
    DWORD transformed     : 1;
2749
    DWORD vertexblends    : 2;
2750
    DWORD clipping        : 1;
2751 2752 2753 2754
    DWORD normal          : 1;
    DWORD normalize       : 1;
    DWORD lighting        : 1;
    DWORD localviewer     : 1;
2755

2756
    DWORD point_size      : 1;
2757
    DWORD per_vertex_point_size : 1;
2758 2759
    DWORD fog_mode        : 2;
    DWORD texcoords       : 8;  /* MAX_TEXTURES */
2760
    DWORD ortho_fog       : 1;
2761
    DWORD flatshading     : 1;
2762 2763
    DWORD swizzle_map     : 16; /* MAX_ATTRIBS, 16 */
    DWORD padding         : 2;
2764

2765
    DWORD texgen[MAX_TEXTURES];
2766 2767 2768 2769 2770 2771 2772 2773
};

struct wined3d_ffp_vs_desc
{
    struct wine_rb_entry entry;
    struct wined3d_ffp_vs_settings settings;
};

2774 2775
void wined3d_ffp_get_vs_settings(const struct wined3d_context *context,
        const struct wined3d_state *state, struct wined3d_ffp_vs_settings *settings) DECLSPEC_HIDDEN;
2776

2777
struct wined3d
2778
{
2779
    LONG ref;
2780
    DWORD flags;
2781
    UINT adapter_count;
2782
    struct wined3d_adapter adapters[1];
2783
};
2784

2785
HRESULT wined3d_init(struct wined3d *wined3d, DWORD flags) DECLSPEC_HIDDEN;
2786
BOOL wined3d_register_window(HWND window, struct wined3d_device *device) DECLSPEC_HIDDEN;
2787
void wined3d_unregister_window(HWND window) DECLSPEC_HIDDEN;
2788

2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799
struct wined3d_blend_state
{
    LONG refcount;
    struct wined3d_blend_state_desc desc;

    void *parent;
    const struct wined3d_parent_ops *parent_ops;

    struct wined3d_device *device;
};

2800 2801 2802 2803 2804
struct wined3d_rasterizer_state
{
    LONG refcount;
    struct wined3d_rasterizer_state_desc desc;

2805 2806 2807
    void *parent;
    const struct wined3d_parent_ops *parent_ops;

2808 2809 2810
    struct wined3d_device *device;
};

2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825
struct wined3d_stream_output
{
    struct wined3d_buffer *buffer;
    UINT offset;
};

struct wined3d_stream_state
{
    struct wined3d_buffer *buffer;
    UINT offset;
    UINT stride;
    UINT frequency;
    UINT flags;
};

2826
#define WINED3D_STATE_NO_REF        0x00000001
2827
#define WINED3D_STATE_INIT_DEFAULT  0x00000002
2828

2829 2830
struct wined3d_state
{
2831
    DWORD flags;
2832 2833 2834
    const struct wined3d_fb_state *fb;

    struct wined3d_vertex_declaration *vertex_declaration;
2835
    struct wined3d_stream_output stream_output[WINED3D_MAX_STREAM_OUTPUT_BUFFERS];
2836 2837 2838
    struct wined3d_stream_state streams[MAX_STREAMS + 1 /* tesselated pseudo-stream */];
    struct wined3d_buffer *index_buffer;
    enum wined3d_format_id index_format;
2839 2840 2841
    unsigned int index_offset;
    int base_vertex_index;
    int load_base_vertex_index; /* Non-indexed drawing needs 0 here, indexed needs base_vertex_index. */
2842
    GLenum gl_primitive_type;
2843
    GLint gl_patch_vertices;
2844 2845
    struct wined3d_query *predicate;
    BOOL predicate_value;
2846

2847
    struct wined3d_shader *shader[WINED3D_SHADER_TYPE_COUNT];
2848
    struct wined3d_buffer *cb[WINED3D_SHADER_TYPE_COUNT][MAX_CONSTANT_BUFFERS];
2849
    struct wined3d_sampler *sampler[WINED3D_SHADER_TYPE_COUNT][MAX_SAMPLER_OBJECTS];
2850
    struct wined3d_shader_resource_view *shader_resource_view[WINED3D_SHADER_TYPE_COUNT][MAX_SHADER_RESOURCE_VIEWS];
2851
    struct wined3d_unordered_access_view *unordered_access_view[WINED3D_PIPELINE_COUNT][MAX_UNORDERED_ACCESS_VIEWS];
2852

2853
    BOOL vs_consts_b[WINED3D_MAX_CONSTS_B];
2854
    struct wined3d_ivec4 vs_consts_i[WINED3D_MAX_CONSTS_I];
2855
    struct wined3d_vec4 vs_consts_f[WINED3D_MAX_VS_CONSTS_F];
2856

2857
    BOOL ps_consts_b[WINED3D_MAX_CONSTS_B];
2858
    struct wined3d_ivec4 ps_consts_i[WINED3D_MAX_CONSTS_I];
2859
    struct wined3d_vec4 ps_consts_f[WINED3D_MAX_PS_CONSTS_F];
2860 2861 2862 2863 2864 2865

    struct wined3d_texture *textures[MAX_COMBINED_SAMPLERS];
    DWORD sampler_states[MAX_COMBINED_SAMPLERS][WINED3D_HIGHEST_SAMPLER_STATE + 1];
    DWORD texture_states[MAX_TEXTURES][WINED3D_HIGHEST_TEXTURE_STATE + 1];

    struct wined3d_matrix transforms[HIGHEST_TRANSFORMSTATE + 1];
2866
    struct wined3d_vec4 clip_planes[MAX_CLIP_DISTANCES];
2867
    struct wined3d_material material;
2868 2869
    struct wined3d_viewport viewports[WINED3D_MAX_VIEWPORTS];
    unsigned int viewport_count;
2870 2871
    RECT scissor_rects[WINED3D_MAX_VIEWPORTS];
    unsigned int scissor_rect_count;
2872 2873 2874 2875 2876 2877 2878 2879

    /* Light hashmap. Collisions are handled using linked lists. */
#define LIGHTMAP_SIZE 43
#define LIGHTMAP_HASHFUNC(x) ((x) % LIGHTMAP_SIZE)
    struct list light_map[LIGHTMAP_SIZE];
    const struct wined3d_light_info *lights[MAX_ACTIVE_LIGHTS];

    DWORD render_states[WINEHIGHEST_RENDER_STATE + 1];
2880
    struct wined3d_blend_state *blend_state;
2881
    struct wined3d_rasterizer_state *rasterizer_state;
2882 2883
};

2884 2885
struct wined3d_dummy_textures
{
2886
    GLuint tex_1d;
2887 2888 2889 2890 2891
    GLuint tex_2d;
    GLuint tex_rect;
    GLuint tex_3d;
    GLuint tex_cube;
    GLuint tex_cube_array;
2892
    GLuint tex_1d_array;
2893 2894 2895 2896 2897 2898
    GLuint tex_2d_array;
    GLuint tex_buffer;
    GLuint tex_2d_ms;
    GLuint tex_2d_ms_array;
};

2899
#define WINED3D_UNMAPPED_STAGE ~0u
2900

2901 2902
/* Multithreaded flag. Removed from the public header to signal that
 * wined3d_device_create() ignores it. */
2903 2904
#define WINED3DCREATE_MULTITHREADED 0x00000004

2905
struct wined3d_device
2906
{
2907
    LONG ref;
2908

2909
    /* WineD3D Information  */
2910
    struct wined3d_device_parent *device_parent;
2911
    struct wined3d *wined3d;
2912
    struct wined3d_adapter *adapter;
2913

2914 2915 2916 2917
    /* Window styles to restore when switching fullscreen mode */
    LONG                    style;
    LONG                    exStyle;

2918
    const struct wined3d_shader_backend_ops *shader_backend;
2919
    void *shader_priv;
2920
    void *fragment_priv;
2921
    void *vertex_priv;
2922
    struct StateEntry StateTable[STATE_HIGHEST + 1];
2923 2924
    /* Array of functions for states which are handled by more than one pipeline part */
    APPLYSTATEFUNC *multistate_funcs[STATE_HIGHEST + 1];
2925
    struct wined3d_blitter *blitter;
2926

2927 2928 2929 2930 2931
    BYTE bCursorVisible : 1;
    BYTE d3d_initialized : 1;
    BYTE inScene : 1;                   /* A flag to check for proper BeginScene / EndScene call pairs */
    BYTE softwareVertexProcessing : 1;  /* process vertex shaders using software or hardware */
    BYTE filter_messages : 1;
2932
    BYTE padding : 3;
2933

2934
    unsigned char           surface_alignment; /* Line Alignment of surfaces                      */
2935

2936 2937
    WORD padding2 : 16;

2938
    struct wined3d_state state;
2939 2940
    struct wined3d_state *update_state;
    struct wined3d_stateblock *recording;
2941

2942
    /* Internal use fields  */
2943
    struct wined3d_device_creation_parameters create_parms;
2944
    HWND focus_window;
2945

2946
    struct wined3d_rendertarget_view *back_buffer_view;
2947
    struct wined3d_swapchain **swapchains;
2948
    UINT swapchain_count;
2949
    unsigned int max_frame_latency;
Oliver Stieber's avatar
Oliver Stieber committed
2950

2951
    struct list             resources; /* a linked list to track resources created by the device */
2952
    struct list             shaders;   /* a linked list to track shaders (pixel and vertex)      */
2953
    struct wine_rb_tree samplers;
2954

2955
    /* Render Target Support */
2956
    struct wined3d_fb_state fb;
2957
    struct wined3d_rendertarget_view *auto_depth_stencil_view;
2958

2959 2960 2961 2962 2963
    /* Cursor management */
    UINT                    xHotSpot;
    UINT                    yHotSpot;
    UINT                    xScreenSpace;
    UINT                    yScreenSpace;
2964
    UINT                    cursorWidth, cursorHeight;
2965
    struct wined3d_texture *cursor_texture;
2966
    HCURSOR                 hardwareCursor;
2967

2968 2969
    /* The Wine logo texture */
    struct wined3d_texture *logo_texture;
2970

2971
    /* Textures for when no other textures are mapped */
2972
    struct wined3d_dummy_textures dummy_textures;
2973

2974
    /* Default sampler used to emulate the direct resource access without using wined3d_sampler */
2975
    struct wined3d_sampler *default_sampler;
2976
    struct wined3d_sampler *null_sampler;
2977

2978 2979 2980
    /* Command stream */
    struct wined3d_cs *cs;

2981
    /* Context management */
2982
    struct wined3d_context **contexts;
2983
    UINT context_count;
2984
};
2985

2986
void device_clear_render_targets(struct wined3d_device *device, UINT rt_count, const struct wined3d_fb_state *fb,
2987
        UINT rect_count, const RECT *rects, const RECT *draw_rect, DWORD flags,
2988
        const struct wined3d_color *color, float depth, DWORD stencil) DECLSPEC_HIDDEN;
2989 2990 2991
BOOL device_context_add(struct wined3d_device *device, struct wined3d_context *context) DECLSPEC_HIDDEN;
void device_context_remove(struct wined3d_device *device, struct wined3d_context *context) DECLSPEC_HIDDEN;
HRESULT device_init(struct wined3d_device *device, struct wined3d *wined3d,
2992
        UINT adapter_idx, enum wined3d_device_type device_type, HWND focus_window, DWORD flags,
2993
        BYTE surface_alignment, struct wined3d_device_parent *device_parent) DECLSPEC_HIDDEN;
2994
LRESULT device_process_message(struct wined3d_device *device, HWND window, BOOL unicode,
2995
        UINT message, WPARAM wparam, LPARAM lparam, WNDPROC proc) DECLSPEC_HIDDEN;
2996 2997
void device_resource_add(struct wined3d_device *device, struct wined3d_resource *resource) DECLSPEC_HIDDEN;
void device_resource_released(struct wined3d_device *device, struct wined3d_resource *resource) DECLSPEC_HIDDEN;
2998
void device_invalidate_state(const struct wined3d_device *device, DWORD state) DECLSPEC_HIDDEN;
2999

3000
static inline BOOL isStateDirty(const struct wined3d_context *context, DWORD state)
3001
{
3002 3003
    DWORD idx = state / (sizeof(*context->isStateDirty) * CHAR_BIT);
    BYTE shift = state & ((sizeof(*context->isStateDirty) * CHAR_BIT) - 1);
3004
    return context->isStateDirty[idx] & (1u << shift);
3005 3006
}

3007 3008
const char *wined3d_debug_resource_access(DWORD access) DECLSPEC_HIDDEN;

3009 3010 3011 3012 3013
static inline BOOL wined3d_resource_access_is_managed(unsigned int access)
{
    return !(~access & (WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_CPU));
}

3014 3015
struct wined3d_resource_ops
{
3016 3017
    ULONG (*resource_incref)(struct wined3d_resource *resource);
    ULONG (*resource_decref)(struct wined3d_resource *resource);
3018
    void (*resource_preload)(struct wined3d_resource *resource);
3019
    void (*resource_unload)(struct wined3d_resource *resource);
3020 3021
    HRESULT (*resource_sub_resource_map)(struct wined3d_resource *resource, unsigned int sub_resource_idx,
            struct wined3d_map_desc *map_desc, const struct wined3d_box *box, DWORD flags);
3022
    HRESULT (*resource_sub_resource_unmap)(struct wined3d_resource *resource, unsigned int sub_resource_idx);
3023 3024
};

3025
struct wined3d_resource
3026
{
3027
    LONG ref;
3028
    LONG bind_count;
3029
    LONG map_count;
3030
    LONG access_count;
3031
    struct wined3d_device *device;
3032
    enum wined3d_resource_type type;
3033
    enum wined3d_gl_resource_type gl_type;
3034
    const struct wined3d_format *format;
3035
    unsigned int format_flags;
3036
    enum wined3d_multisample_type multisample_type;
3037 3038
    UINT multisample_quality;
    DWORD usage;
3039
    unsigned int access;
3040 3041
    WORD draw_binding;
    WORD map_binding;
3042 3043 3044
    UINT width;
    UINT height;
    UINT depth;
3045 3046 3047
    UINT size;
    DWORD priority;
    void *heap_memory;
3048 3049

    void *parent;
3050
    const struct wined3d_parent_ops *parent_ops;
3051
    const struct wined3d_resource_ops *resource_ops;
3052 3053

    struct list resource_list_entry;
3054
};
3055

3056 3057 3058 3059 3060 3061 3062 3063 3064 3065
static inline ULONG wined3d_resource_incref(struct wined3d_resource *resource)
{
    return resource->resource_ops->resource_incref(resource);
}

static inline ULONG wined3d_resource_decref(struct wined3d_resource *resource)
{
    return resource->resource_ops->resource_decref(resource);
}

3066 3067 3068 3069 3070 3071 3072 3073 3074 3075
static inline void wined3d_resource_acquire(struct wined3d_resource *resource)
{
    InterlockedIncrement(&resource->access_count);
}

static inline void wined3d_resource_release(struct wined3d_resource *resource)
{
    InterlockedDecrement(&resource->access_count);
}

3076
void resource_cleanup(struct wined3d_resource *resource) DECLSPEC_HIDDEN;
3077
HRESULT resource_init(struct wined3d_resource *resource, struct wined3d_device *device,
3078
        enum wined3d_resource_type type, const struct wined3d_format *format,
3079 3080 3081
        enum wined3d_multisample_type multisample_type, unsigned int multisample_quality,
        unsigned int usage, unsigned int access, unsigned int width, unsigned int height, unsigned int depth,
        unsigned int size, void *parent, const struct wined3d_parent_ops *parent_ops,
3082
        const struct wined3d_resource_ops *resource_ops) DECLSPEC_HIDDEN;
3083
void resource_unload(struct wined3d_resource *resource) DECLSPEC_HIDDEN;
3084
BOOL wined3d_resource_allocate_sysmem(struct wined3d_resource *resource) DECLSPEC_HIDDEN;
3085
void wined3d_resource_free_sysmem(struct wined3d_resource *resource) DECLSPEC_HIDDEN;
3086 3087
const struct wined3d_format *wined3d_resource_get_decompress_format(struct wined3d_resource *resource,
        const struct wined3d_context *context) DECLSPEC_HIDDEN;
3088
GLbitfield wined3d_resource_gl_map_flags(DWORD d3d_flags) DECLSPEC_HIDDEN;
3089
GLenum wined3d_resource_gl_legacy_map_flags(DWORD d3d_flags) DECLSPEC_HIDDEN;
3090
BOOL wined3d_resource_is_offscreen(struct wined3d_resource *resource) DECLSPEC_HIDDEN;
3091
void wined3d_resource_update_draw_binding(struct wined3d_resource *resource) DECLSPEC_HIDDEN;
3092

3093
/* Tests show that the start address of resources is 32 byte aligned */
3094
#define RESOURCE_ALIGNMENT 16
3095
#define WINED3D_CONSTANT_BUFFER_ALIGNMENT 16
3096

3097 3098
struct gl_texture
{
3099 3100 3101
    struct wined3d_sampler_desc sampler_desc;
    unsigned int base_level;
    GLuint name;
3102 3103
};

3104 3105 3106 3107 3108 3109
struct wined3d_blt_info
{
    GLenum bind_target;
    struct wined3d_vec3 texcoords[4];
};

3110 3111
struct wined3d_texture_ops
{
3112 3113
    BOOL (*texture_load_location)(struct wined3d_texture *texture, unsigned int sub_resource_idx,
            struct wined3d_context *context, DWORD location);
3114 3115
};

3116
#define WINED3D_TEXTURE_COND_NP2            0x00000001
3117 3118 3119 3120 3121 3122 3123 3124 3125
#define WINED3D_TEXTURE_COND_NP2_EMULATED   0x00000002
#define WINED3D_TEXTURE_POW2_MAT_IDENT      0x00000004
#define WINED3D_TEXTURE_IS_SRGB             0x00000008
#define WINED3D_TEXTURE_RGB_ALLOCATED       0x00000010
#define WINED3D_TEXTURE_RGB_VALID           0x00000020
#define WINED3D_TEXTURE_SRGB_ALLOCATED      0x00000040
#define WINED3D_TEXTURE_SRGB_VALID          0x00000080
#define WINED3D_TEXTURE_CONVERTED           0x00000100
#define WINED3D_TEXTURE_PIN_SYSMEM          0x00000200
3126
#define WINED3D_TEXTURE_NORMALIZED_COORDS   0x00000400
3127
#define WINED3D_TEXTURE_GET_DC_LENIENT      0x00000800
3128
#define WINED3D_TEXTURE_DC_IN_USE           0x00001000
3129
#define WINED3D_TEXTURE_DISCARD             0x00002000
3130
#define WINED3D_TEXTURE_GET_DC              0x00004000
3131
#define WINED3D_TEXTURE_GENERATE_MIPMAPS    0x00008000
3132 3133

#define WINED3D_TEXTURE_ASYNC_COLOR_KEY     0x00000001
3134

3135
struct wined3d_texture
3136
{
3137
    struct wined3d_resource resource;
3138
    const struct wined3d_texture_ops *texture_ops;
3139
    struct gl_texture texture_rgb, texture_srgb;
3140
    struct wined3d_swapchain *swapchain;
3141 3142
    unsigned int pow2_width;
    unsigned int pow2_height;
3143 3144
    UINT layer_count;
    UINT level_count;
3145
    unsigned int download_count;
3146
    unsigned int sysmem_count;
3147 3148 3149
    float pow2_matrix[16];
    UINT lod;
    DWORD sampler;
3150
    DWORD flags;
3151
    GLenum target;
3152
    DWORD update_map_binding;
3153

3154 3155 3156
    GLuint rb_multisample;
    GLuint rb_resolved;

3157
    void *user_memory;
3158
    unsigned int row_pitch;
3159
    unsigned int slice_pitch;
3160

3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173
    /* May only be accessed from the command stream worker thread. */
    struct wined3d_texture_async
    {
        DWORD flags;

        /* Color keys for DDraw */
        struct wined3d_color_key dst_blt_color_key;
        struct wined3d_color_key src_blt_color_key;
        struct wined3d_color_key dst_overlay_color_key;
        struct wined3d_color_key src_overlay_color_key;
        struct wined3d_color_key gl_color_key;
        DWORD color_key_flags;
    } async;
3174

3175 3176 3177 3178
    struct wined3d_overlay_info
    {
        struct list entry;
        struct list overlays;
3179 3180
        struct wined3d_texture *dst_texture;
        unsigned int dst_sub_resource_idx;
3181 3182 3183 3184
        RECT src_rect;
        RECT dst_rect;
    } *overlay_info;

3185 3186 3187 3188 3189 3190
    struct wined3d_dc_info
    {
        HBITMAP bitmap;
        HDC dc;
    } *dc_info;

3191 3192 3193
    struct list renderbuffers;
    const struct wined3d_renderbuffer_entry *current_renderbuffer;

3194
    struct wined3d_texture_sub_resource
3195
    {
3196 3197 3198
        void *parent;
        const struct wined3d_parent_ops *parent_ops;

3199 3200
        unsigned int offset;
        unsigned int size;
3201

3202
        unsigned int map_count;
3203
        DWORD locations;
3204
        GLuint buffer_object;
3205
    } sub_resources[1];
3206
};
3207

3208
static inline struct wined3d_texture *texture_from_resource(struct wined3d_resource *resource)
3209
{
3210
    return CONTAINING_RECORD(resource, struct wined3d_texture, resource);
3211 3212
}

3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229
static inline GLenum wined3d_texture_get_sub_resource_target(const struct wined3d_texture *texture,
        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,
    };

    return texture->resource.usage & WINED3DUSAGE_LEGACY_CUBEMAP
            ? cube_targets[sub_resource_idx / texture->level_count] : texture->target;
}

3230
static inline struct gl_texture *wined3d_texture_get_gl_texture(struct wined3d_texture *texture,
3231
        BOOL srgb)
3232
{
3233
    return srgb ? &texture->texture_srgb : &texture->texture_rgb;
3234 3235
}

3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253
static inline unsigned int wined3d_texture_get_level_width(const struct wined3d_texture *texture,
        unsigned int level)
{
    return max(1, texture->resource.width >> level);
}

static inline unsigned int wined3d_texture_get_level_height(const struct wined3d_texture *texture,
        unsigned int level)
{
    return max(1, texture->resource.height >> level);
}

static inline unsigned int wined3d_texture_get_level_depth(const struct wined3d_texture *texture,
        unsigned int level)
{
    return max(1, texture->resource.depth >> level);
}

3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265
static inline unsigned int wined3d_texture_get_level_pow2_width(const struct wined3d_texture *texture,
        unsigned int level)
{
    return max(1, texture->pow2_width >> level);
}

static inline unsigned int wined3d_texture_get_level_pow2_height(const struct wined3d_texture *texture,
        unsigned int level)
{
    return max(1, texture->pow2_height >> level);
}

3266 3267 3268 3269 3270 3271 3272 3273 3274
static inline void wined3d_texture_get_level_box(const struct wined3d_texture *texture,
        unsigned int level, struct wined3d_box *box)
{
    wined3d_box_set(box, 0, 0,
            wined3d_texture_get_level_width(texture, level),
            wined3d_texture_get_level_height(texture, level),
            0, wined3d_texture_get_level_depth(texture, level));
}

3275 3276 3277 3278
HRESULT texture2d_blt(struct wined3d_texture *dst_texture, unsigned int dst_sub_resource_idx,
        const struct wined3d_box *dst_box, struct wined3d_texture *src_texture,
        unsigned int src_sub_resource_idx, const struct wined3d_box *src_box, DWORD flags,
        const struct wined3d_blt_fx *blt_fx, enum wined3d_texture_filter_type filter) DECLSPEC_HIDDEN;
3279 3280
void texture2d_get_blt_info(const struct wined3d_texture *texture, unsigned int sub_resource_idx,
        const RECT *rect, struct wined3d_blt_info *info) DECLSPEC_HIDDEN;
3281 3282
BOOL texture2d_load_drawable(struct wined3d_texture *texture, unsigned int sub_resource_idx,
        struct wined3d_context *context) DECLSPEC_HIDDEN;
3283 3284
void texture2d_load_fb_texture(struct wined3d_texture *texture, unsigned int sub_resource_idx,
        BOOL srgb, struct wined3d_context *context) DECLSPEC_HIDDEN;
3285 3286
BOOL texture2d_load_renderbuffer(struct wined3d_texture *texture, unsigned int sub_resource_idx,
        struct wined3d_context *context, DWORD dst_location) DECLSPEC_HIDDEN;
3287 3288
BOOL texture2d_load_sysmem(struct wined3d_texture *texture, unsigned int sub_resource_idx,
        struct wined3d_context *context, DWORD dst_location) DECLSPEC_HIDDEN;
3289 3290
BOOL texture2d_load_texture(struct wined3d_texture *texture, unsigned int sub_resource_idx,
        struct wined3d_context *context, BOOL srgb) DECLSPEC_HIDDEN;
3291

3292
void wined3d_texture_apply_sampler_desc(struct wined3d_texture *texture,
3293
        const struct wined3d_sampler_desc *sampler_desc, const struct wined3d_context *context) DECLSPEC_HIDDEN;
3294 3295
void wined3d_texture_bind(struct wined3d_texture *texture,
        struct wined3d_context *context, BOOL srgb) DECLSPEC_HIDDEN;
3296 3297
void wined3d_texture_bind_and_dirtify(struct wined3d_texture *texture,
        struct wined3d_context *context, BOOL srgb) DECLSPEC_HIDDEN;
3298
HRESULT wined3d_texture_check_box_dimensions(const struct wined3d_texture *texture,
3299
        unsigned int level, const struct wined3d_box *box) DECLSPEC_HIDDEN;
3300
GLenum wined3d_texture_get_gl_buffer(const struct wined3d_texture *texture) DECLSPEC_HIDDEN;
3301 3302
void wined3d_texture_get_memory(struct wined3d_texture *texture, unsigned int sub_resource_idx,
        struct wined3d_bo_address *data, DWORD locations) DECLSPEC_HIDDEN;
3303 3304
void wined3d_texture_invalidate_location(struct wined3d_texture *texture,
        unsigned int sub_resource_idx, DWORD location) DECLSPEC_HIDDEN;
3305
void wined3d_texture_load(struct wined3d_texture *texture,
3306
        struct wined3d_context *context, BOOL srgb) DECLSPEC_HIDDEN;
3307 3308
BOOL wined3d_texture_load_location(struct wined3d_texture *texture,
        unsigned int sub_resource_idx, struct wined3d_context *context, DWORD location) DECLSPEC_HIDDEN;
3309 3310
BOOL wined3d_texture_prepare_location(struct wined3d_texture *texture, unsigned int sub_resource_idx,
        struct wined3d_context *context, DWORD location) DECLSPEC_HIDDEN;
3311 3312
void wined3d_texture_prepare_texture(struct wined3d_texture *texture,
        struct wined3d_context *context, BOOL srgb) DECLSPEC_HIDDEN;
3313 3314
void wined3d_texture_set_compatible_renderbuffer(struct wined3d_texture *texture,
        unsigned int level, const struct wined3d_rendertarget_info *rt) DECLSPEC_HIDDEN;
3315
void wined3d_texture_set_map_binding(struct wined3d_texture *texture, DWORD map_binding) DECLSPEC_HIDDEN;
3316 3317
void wined3d_texture_set_swapchain(struct wined3d_texture *texture,
        struct wined3d_swapchain *swapchain) DECLSPEC_HIDDEN;
3318 3319
void wined3d_texture_translate_drawable_coords(const struct wined3d_texture *texture,
        HWND window, RECT *rect) DECLSPEC_HIDDEN;
3320
void wined3d_texture_upload_data(struct wined3d_texture *texture, unsigned int sub_resource_idx,
3321
        struct wined3d_context *context, const struct wined3d_format *format, const struct wined3d_box *src_box,
3322
        const struct wined3d_const_bo_address *data, unsigned int row_pitch, unsigned int slice_pitch,
3323
        unsigned int dst_x, unsigned int dst_y, unsigned int dst_z, BOOL srgb) DECLSPEC_HIDDEN;
3324 3325 3326
void wined3d_texture_upload_from_texture(struct wined3d_texture *dst_texture, unsigned int dst_sub_resource_idx,
        unsigned int dst_x, unsigned int dst_y, unsigned int dst_z, struct wined3d_texture *src_texture,
        unsigned int src_sub_resource_idx, const struct wined3d_box *src_box) DECLSPEC_HIDDEN;
3327 3328
void wined3d_texture_validate_location(struct wined3d_texture *texture,
        unsigned int sub_resource_idx, DWORD location) DECLSPEC_HIDDEN;
3329

3330 3331
#define WINED3D_LOCATION_DISCARDED      0x00000001
#define WINED3D_LOCATION_SYSMEM         0x00000002
3332
#define WINED3D_LOCATION_USER_MEMORY    0x00000004
3333 3334 3335 3336 3337 3338
#define WINED3D_LOCATION_BUFFER         0x00000008
#define WINED3D_LOCATION_TEXTURE_RGB    0x00000010
#define WINED3D_LOCATION_TEXTURE_SRGB   0x00000020
#define WINED3D_LOCATION_DRAWABLE       0x00000040
#define WINED3D_LOCATION_RB_MULTISAMPLE 0x00000080
#define WINED3D_LOCATION_RB_RESOLVED    0x00000100
3339 3340 3341

const char *wined3d_debug_location(DWORD location) DECLSPEC_HIDDEN;

3342 3343
struct wined3d_renderbuffer_entry
{
3344 3345 3346 3347
    struct list entry;
    GLuint id;
    UINT width;
    UINT height;
3348
};
3349

3350 3351 3352
struct wined3d_fbo_resource
{
    GLuint object;
3353 3354
    GLenum target;
    GLuint level, layer;
3355 3356
};

3357 3358 3359 3360
#define WINED3D_FBO_ENTRY_FLAG_ATTACHED      0x1
#define WINED3D_FBO_ENTRY_FLAG_DEPTH         0x2
#define WINED3D_FBO_ENTRY_FLAG_STENCIL       0x4

3361 3362 3363
struct fbo_entry
{
    struct list entry;
3364
    DWORD flags;
3365
    DWORD rt_mask;
3366
    GLuint id;
3367 3368 3369
    struct wined3d_fbo_entry_key
    {
        DWORD rb_namespace;
3370
        struct wined3d_fbo_resource objects[MAX_RENDER_TARGET_VIEWS + 1];
3371
    } key;
3372 3373
};

3374 3375
struct wined3d_sampler
{
3376
    struct wine_rb_entry entry;
3377
    LONG refcount;
3378
    GLuint name;
3379
    struct wined3d_device *device;
3380
    void *parent;
3381
    const struct wined3d_parent_ops *parent_ops;
3382
    struct wined3d_sampler_desc desc;
3383 3384
};

3385 3386 3387
void wined3d_sampler_bind(struct wined3d_sampler *sampler, unsigned int unit,
        struct wined3d_texture *texture, const struct wined3d_context *context) DECLSPEC_HIDDEN;

3388 3389
struct wined3d_vertex_declaration_element
{
3390
    const struct wined3d_format *format;
3391
    BOOL ffp_valid;
3392 3393
    unsigned int input_slot;
    unsigned int offset;
3394 3395 3396
    unsigned int output_slot;
    enum wined3d_input_classification input_slot_class;
    unsigned int instance_data_step_rate;
3397 3398 3399 3400 3401
    BYTE method;
    BYTE usage;
    BYTE usage_idx;
};

3402 3403 3404
struct wined3d_vertex_declaration
{
    LONG ref;
3405
    void *parent;
3406
    const struct wined3d_parent_ops *parent_ops;
3407
    struct wined3d_device *device;
3408

3409 3410
    struct wined3d_vertex_declaration_element *elements;
    UINT element_count;
3411

3412 3413
    BOOL position_transformed;
    BOOL half_float_conv_needed;
3414
};
3415

3416 3417
struct wined3d_saved_states
{
3418
    DWORD transform[(HIGHEST_TRANSFORMSTATE >> 5) + 1];
3419 3420
    WORD streamSource;                          /* MAX_STREAMS, 16 */
    WORD streamFreq;                            /* MAX_STREAMS, 16 */
3421
    DWORD renderState[(WINEHIGHEST_RENDER_STATE >> 5) + 1];
3422 3423
    DWORD textureState[MAX_TEXTURES];           /* WINED3D_HIGHEST_TEXTURE_STATE + 1, 18 */
    WORD samplerState[MAX_COMBINED_SAMPLERS];   /* WINED3D_HIGHEST_SAMPLER_STATE + 1, 14 */
3424
    DWORD clipplane;                            /* WINED3D_MAX_USER_CLIP_PLANES, 32 */
3425
    WORD pixelShaderConstantsB;                 /* WINED3D_MAX_CONSTS_B, 16 */
3426
    WORD pixelShaderConstantsI;                 /* WINED3D_MAX_CONSTS_I, 16 */
3427
    BOOL ps_consts_f[WINED3D_MAX_PS_CONSTS_F];
3428
    WORD vertexShaderConstantsB;                /* WINED3D_MAX_CONSTS_B, 16 */
3429
    WORD vertexShaderConstantsI;                /* WINED3D_MAX_CONSTS_I, 16 */
3430
    BOOL vs_consts_f[WINED3D_MAX_VS_CONSTS_F];
3431 3432 3433 3434 3435 3436 3437 3438
    DWORD textures : 20;                        /* MAX_COMBINED_SAMPLERS, 20 */
    DWORD indices : 1;
    DWORD material : 1;
    DWORD viewport : 1;
    DWORD vertexDecl : 1;
    DWORD pixelShader : 1;
    DWORD vertexShader : 1;
    DWORD scissorRect : 1;
3439
    DWORD padding : 5;
3440
};
3441

3442 3443 3444 3445 3446
struct StageState {
    DWORD stage;
    DWORD state;
};

3447
struct wined3d_stateblock
3448
{
3449
    LONG                      ref;     /* Note: Ref counting not required */
3450
    struct wined3d_device *device;
3451 3452

    /* Array indicating whether things have been set or changed */
3453
    struct wined3d_saved_states changed;
3454
    struct wined3d_state state;
3455

3456 3457 3458
    /* Contained state management */
    DWORD                     contained_render_states[WINEHIGHEST_RENDER_STATE + 1];
    unsigned int              num_contained_render_states;
3459
    DWORD                     contained_transform_states[HIGHEST_TRANSFORMSTATE + 1];
3460
    unsigned int              num_contained_transform_states;
3461
    DWORD                     contained_vs_consts_i[WINED3D_MAX_CONSTS_I];
3462
    unsigned int              num_contained_vs_consts_i;
3463
    DWORD                     contained_vs_consts_b[WINED3D_MAX_CONSTS_B];
3464
    unsigned int              num_contained_vs_consts_b;
3465
    DWORD                     contained_vs_consts_f[WINED3D_MAX_VS_CONSTS_F];
3466
    unsigned int              num_contained_vs_consts_f;
3467
    DWORD                     contained_ps_consts_i[WINED3D_MAX_CONSTS_I];
3468
    unsigned int              num_contained_ps_consts_i;
3469
    DWORD                     contained_ps_consts_b[WINED3D_MAX_CONSTS_B];
3470
    unsigned int              num_contained_ps_consts_b;
3471
    DWORD                     contained_ps_consts_f[WINED3D_MAX_PS_CONSTS_F];
3472
    unsigned int              num_contained_ps_consts_f;
3473
    struct StageState         contained_tss_states[MAX_TEXTURES * (WINED3D_HIGHEST_TEXTURE_STATE + 1)];
3474
    unsigned int              num_contained_tss_states;
3475 3476
    struct StageState         contained_sampler_states[MAX_COMBINED_SAMPLERS * WINED3D_HIGHEST_SAMPLER_STATE];
    unsigned int              num_contained_sampler_states;
3477 3478
};

3479
void stateblock_init_contained_states(struct wined3d_stateblock *stateblock) DECLSPEC_HIDDEN;
3480

3481
void state_cleanup(struct wined3d_state *state) DECLSPEC_HIDDEN;
3482 3483
void wined3d_state_enable_light(struct wined3d_state *state, const struct wined3d_d3d_info *d3d_info,
        struct wined3d_light_info *light_info, BOOL enable) DECLSPEC_HIDDEN;
3484 3485
struct wined3d_light_info *wined3d_state_get_light(const struct wined3d_state *state,
        unsigned int idx) DECLSPEC_HIDDEN;
3486
void state_init(struct wined3d_state *state, struct wined3d_fb_state *fb,
3487 3488
        const struct wined3d_gl_info *gl_info, const struct wined3d_d3d_info *d3d_info,
        DWORD flags) DECLSPEC_HIDDEN;
3489
void state_unbind_resources(struct wined3d_state *state) DECLSPEC_HIDDEN;
3490

3491 3492 3493 3494 3495 3496 3497
enum wined3d_cs_queue_id
{
    WINED3D_CS_QUEUE_DEFAULT = 0,
    WINED3D_CS_QUEUE_MAP,
    WINED3D_CS_QUEUE_COUNT,
};

3498 3499 3500 3501 3502 3503 3504 3505 3506 3507
enum wined3d_push_constants
{
    WINED3D_PUSH_CONSTANTS_VS_F,
    WINED3D_PUSH_CONSTANTS_PS_F,
    WINED3D_PUSH_CONSTANTS_VS_I,
    WINED3D_PUSH_CONSTANTS_PS_I,
    WINED3D_PUSH_CONSTANTS_VS_B,
    WINED3D_PUSH_CONSTANTS_PS_B,
};

3508 3509 3510 3511 3512 3513 3514 3515 3516 3517
#define WINED3D_CS_QUERY_POLL_INTERVAL  10u
#define WINED3D_CS_QUEUE_SIZE           0x100000u
#define WINED3D_CS_SPIN_COUNT           10000000u

struct wined3d_cs_queue
{
    LONG head, tail;
    BYTE data[WINED3D_CS_QUEUE_SIZE];
};

3518 3519
struct wined3d_cs_ops
{
3520 3521 3522
    void *(*require_space)(struct wined3d_cs *cs, size_t size, enum wined3d_cs_queue_id queue_id);
    void (*submit)(struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id);
    void (*finish)(struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id);
3523 3524
    void (*push_constants)(struct wined3d_cs *cs, enum wined3d_push_constants p,
            unsigned int start_idx, unsigned int count, const void *constants);
3525 3526 3527 3528 3529
};

struct wined3d_cs
{
    const struct wined3d_cs_ops *ops;
3530
    struct wined3d_device *device;
3531 3532
    struct wined3d_fb_state fb;
    struct wined3d_state state;
3533
    HMODULE wined3d_module;
3534 3535
    HANDLE thread;
    DWORD thread_id;
3536

3537
    struct wined3d_cs_queue queue[WINED3D_CS_QUEUE_COUNT];
3538
    size_t data_size, start, end;
3539
    void *data;
3540
    struct list query_poll_list;
3541
    BOOL queries_flushed;
3542 3543 3544

    HANDLE event;
    BOOL waiting_for_event;
3545
    LONG pending_presents;
3546 3547
};

3548
struct wined3d_cs *wined3d_cs_create(struct wined3d_device *device) DECLSPEC_HIDDEN;
3549
void wined3d_cs_destroy(struct wined3d_cs *cs) DECLSPEC_HIDDEN;
3550 3551
void wined3d_cs_destroy_object(struct wined3d_cs *cs,
        void (*callback)(void *object), void *object) DECLSPEC_HIDDEN;
3552 3553
void wined3d_cs_emit_add_dirty_texture_region(struct wined3d_cs *cs,
        struct wined3d_texture *texture, unsigned int layer) DECLSPEC_HIDDEN;
3554 3555 3556 3557
void wined3d_cs_emit_blt_sub_resource(struct wined3d_cs *cs, struct wined3d_resource *dst_resource,
        unsigned int dst_sub_resource_idx, const struct wined3d_box *dst_box, struct wined3d_resource *src_resource,
        unsigned int src_sub_resource_idx, const struct wined3d_box *src_box, DWORD flags,
        const struct wined3d_blt_fx *fx, enum wined3d_texture_filter_type filter) DECLSPEC_HIDDEN;
3558 3559
void wined3d_cs_emit_clear(struct wined3d_cs *cs, DWORD rect_count, const RECT *rects,
        DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil) DECLSPEC_HIDDEN;
3560 3561
void wined3d_cs_emit_clear_rendertarget_view(struct wined3d_cs *cs, struct wined3d_rendertarget_view *view,
        const RECT *rect, DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil) DECLSPEC_HIDDEN;
3562 3563
void wined3d_cs_emit_clear_unordered_access_view_uint(struct wined3d_cs *cs,
        struct wined3d_unordered_access_view *view, const struct wined3d_uvec4 *clear_value) DECLSPEC_HIDDEN;
3564 3565
void wined3d_cs_emit_copy_uav_counter(struct wined3d_cs *cs, struct wined3d_buffer *dst_buffer,
        unsigned int offset, struct wined3d_unordered_access_view *uav) DECLSPEC_HIDDEN;
3566 3567
void wined3d_cs_emit_dispatch(struct wined3d_cs *cs,
        unsigned int group_count_x, unsigned int group_count_y, unsigned int group_count_z) DECLSPEC_HIDDEN;
3568 3569
void wined3d_cs_emit_dispatch_indirect(struct wined3d_cs *cs,
        struct wined3d_buffer *buffer, unsigned int offset) DECLSPEC_HIDDEN;
3570 3571 3572
void wined3d_cs_emit_draw(struct wined3d_cs *cs, GLenum primitive_type, unsigned int patch_vertex_count,
        int base_vertex_idx, unsigned int start_idx, unsigned int index_count,
        unsigned int start_instance, unsigned int instance_count, BOOL indexed) DECLSPEC_HIDDEN;
3573 3574
void wined3d_cs_emit_draw_indirect(struct wined3d_cs *cs, GLenum primitive_type, unsigned int patch_vertex_count,
        struct wined3d_buffer *buffer, unsigned int offset, BOOL indexed) DECLSPEC_HIDDEN;
3575
void wined3d_cs_emit_flush(struct wined3d_cs *cs) DECLSPEC_HIDDEN;
3576
void wined3d_cs_emit_generate_mipmaps(struct wined3d_cs *cs, struct wined3d_shader_resource_view *view) DECLSPEC_HIDDEN;
3577
void wined3d_cs_emit_preload_resource(struct wined3d_cs *cs, struct wined3d_resource *resource) DECLSPEC_HIDDEN;
3578 3579
void wined3d_cs_emit_present(struct wined3d_cs *cs, struct wined3d_swapchain *swapchain, const RECT *src_rect,
        const RECT *dst_rect, HWND dst_window_override, unsigned int swap_interval, DWORD flags) DECLSPEC_HIDDEN;
3580
void wined3d_cs_emit_query_issue(struct wined3d_cs *cs, struct wined3d_query *query, DWORD flags) DECLSPEC_HIDDEN;
3581
void wined3d_cs_emit_reset_state(struct wined3d_cs *cs) DECLSPEC_HIDDEN;
3582
void wined3d_cs_emit_set_blend_state(struct wined3d_cs *cs, struct wined3d_blend_state *state) DECLSPEC_HIDDEN;
3583 3584
void wined3d_cs_emit_set_clip_plane(struct wined3d_cs *cs, UINT plane_idx,
        const struct wined3d_vec4 *plane) DECLSPEC_HIDDEN;
3585 3586
void wined3d_cs_emit_set_color_key(struct wined3d_cs *cs, struct wined3d_texture *texture,
        WORD flags, const struct wined3d_color_key *color_key) DECLSPEC_HIDDEN;
3587 3588
void wined3d_cs_emit_set_constant_buffer(struct wined3d_cs *cs, enum wined3d_shader_type type,
        UINT cb_idx, struct wined3d_buffer *buffer) DECLSPEC_HIDDEN;
3589 3590
void wined3d_cs_emit_set_depth_stencil_view(struct wined3d_cs *cs,
        struct wined3d_rendertarget_view *view) DECLSPEC_HIDDEN;
3591
void wined3d_cs_emit_set_index_buffer(struct wined3d_cs *cs, struct wined3d_buffer *buffer,
3592
        enum wined3d_format_id format_id, unsigned int offset) DECLSPEC_HIDDEN;
3593
void wined3d_cs_emit_set_light(struct wined3d_cs *cs, const struct wined3d_light_info *light) DECLSPEC_HIDDEN;
3594
void wined3d_cs_emit_set_light_enable(struct wined3d_cs *cs, unsigned int idx, BOOL enable) DECLSPEC_HIDDEN;
3595
void wined3d_cs_emit_set_material(struct wined3d_cs *cs, const struct wined3d_material *material) DECLSPEC_HIDDEN;
3596 3597
void wined3d_cs_emit_set_predication(struct wined3d_cs *cs,
        struct wined3d_query *predicate, BOOL value) DECLSPEC_HIDDEN;
3598 3599
void wined3d_cs_emit_set_rasterizer_state(struct wined3d_cs *cs,
        struct wined3d_rasterizer_state *rasterizer_state) DECLSPEC_HIDDEN;
3600 3601
void wined3d_cs_emit_set_render_state(struct wined3d_cs *cs,
        enum wined3d_render_state state, DWORD value) DECLSPEC_HIDDEN;
3602 3603
void wined3d_cs_emit_set_rendertarget_view(struct wined3d_cs *cs, unsigned int view_idx,
        struct wined3d_rendertarget_view *view) DECLSPEC_HIDDEN;
3604 3605
void wined3d_cs_emit_set_shader_resource_view(struct wined3d_cs *cs, enum wined3d_shader_type type,
        UINT view_idx, struct wined3d_shader_resource_view *view) DECLSPEC_HIDDEN;
3606 3607
void wined3d_cs_emit_set_sampler(struct wined3d_cs *cs, enum wined3d_shader_type type,
        UINT sampler_idx, struct wined3d_sampler *sampler) DECLSPEC_HIDDEN;
3608 3609
void wined3d_cs_emit_set_sampler_state(struct wined3d_cs *cs, UINT sampler_idx,
        enum wined3d_sampler_state state, DWORD value) DECLSPEC_HIDDEN;
3610
void wined3d_cs_emit_set_scissor_rects(struct wined3d_cs *cs, unsigned int rect_count, const RECT *rects) DECLSPEC_HIDDEN;
3611 3612
void wined3d_cs_emit_set_shader(struct wined3d_cs *cs, enum wined3d_shader_type type,
        struct wined3d_shader *shader) DECLSPEC_HIDDEN;
3613 3614
void wined3d_cs_emit_set_stream_output(struct wined3d_cs *cs, UINT stream_idx,
        struct wined3d_buffer *buffer, UINT offset) DECLSPEC_HIDDEN;
3615 3616
void wined3d_cs_emit_set_stream_source(struct wined3d_cs *cs, UINT stream_idx,
        struct wined3d_buffer *buffer, UINT offset, UINT stride) DECLSPEC_HIDDEN;
3617 3618
void wined3d_cs_emit_set_stream_source_freq(struct wined3d_cs *cs, UINT stream_idx,
        UINT frequency, UINT flags) DECLSPEC_HIDDEN;
3619
void wined3d_cs_emit_set_texture(struct wined3d_cs *cs, UINT stage, struct wined3d_texture *texture) DECLSPEC_HIDDEN;
3620 3621
void wined3d_cs_emit_set_texture_state(struct wined3d_cs *cs, UINT stage,
        enum wined3d_texture_stage_state state, DWORD value) DECLSPEC_HIDDEN;
3622 3623
void wined3d_cs_emit_set_transform(struct wined3d_cs *cs, enum wined3d_transform_state state,
        const struct wined3d_matrix *matrix) DECLSPEC_HIDDEN;
3624
void wined3d_cs_emit_set_unordered_access_view(struct wined3d_cs *cs, enum wined3d_pipeline pipeline,
3625 3626
        unsigned int view_idx, struct wined3d_unordered_access_view *view,
        unsigned int initial_count) DECLSPEC_HIDDEN;
3627 3628
void wined3d_cs_emit_set_vertex_declaration(struct wined3d_cs *cs,
        struct wined3d_vertex_declaration *declaration) DECLSPEC_HIDDEN;
3629
void wined3d_cs_emit_set_viewports(struct wined3d_cs *cs, unsigned int viewport_count, const struct wined3d_viewport *viewports) DECLSPEC_HIDDEN;
3630
void wined3d_cs_emit_unload_resource(struct wined3d_cs *cs, struct wined3d_resource *resource) DECLSPEC_HIDDEN;
3631 3632 3633
void wined3d_cs_emit_update_sub_resource(struct wined3d_cs *cs, struct wined3d_resource *resource,
        unsigned int sub_resource_idx, const struct wined3d_box *box, const void *data, unsigned int row_pitch,
        unsigned int slice_pitch) DECLSPEC_HIDDEN;
3634 3635
void wined3d_cs_init_object(struct wined3d_cs *cs,
        void (*callback)(void *object), void *object) DECLSPEC_HIDDEN;
3636 3637
HRESULT wined3d_cs_map(struct wined3d_cs *cs, struct wined3d_resource *resource, unsigned int sub_resource_idx,
        struct wined3d_map_desc *map_desc, const struct wined3d_box *box, unsigned int flags) DECLSPEC_HIDDEN;
3638 3639
HRESULT wined3d_cs_unmap(struct wined3d_cs *cs, struct wined3d_resource *resource,
        unsigned int sub_resource_idx) DECLSPEC_HIDDEN;
3640

3641 3642 3643 3644 3645 3646
static inline void wined3d_cs_push_constants(struct wined3d_cs *cs, enum wined3d_push_constants p,
        unsigned int start_idx, unsigned int count, const void *constants)
{
    cs->ops->push_constants(cs, p, start_idx, count, constants);
}

3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657
static inline void wined3d_resource_wait_idle(struct wined3d_resource *resource)
{
    const struct wined3d_cs *cs = resource->device->cs;

    if (!cs->thread || cs->thread_id == GetCurrentThreadId())
        return;

    while (InterlockedCompareExchange(&resource->access_count, 0, 0))
        wined3d_pause();
}

3658 3659 3660 3661 3662 3663 3664 3665 3666
/* TODO: Add tests and support for FLOAT16_4 POSITIONT, D3DCOLOR position, other
 * fixed function semantics as D3DCOLOR or FLOAT16 */
enum wined3d_buffer_conversion_type
{
    CONV_NONE,
    CONV_D3DCOLOR,
    CONV_POSITIONT,
};

3667 3668 3669 3670 3671 3672
struct wined3d_map_range
{
    UINT offset;
    UINT size;
};

3673 3674
struct wined3d_buffer
{
3675
    struct wined3d_resource resource;
3676 3677

    struct wined3d_buffer_desc desc;
3678 3679 3680

    GLuint buffer_object;
    GLenum buffer_object_usage;
3681
    GLenum buffer_type_hint;
3682
    unsigned int bind_flags;
3683
    DWORD flags;
3684
    DWORD locations;
3685
    void *map_ptr;
3686

3687
    struct wined3d_map_range *maps;
3688
    SIZE_T maps_size, modified_areas;
3689
    struct wined3d_fence *fence;
3690 3691

    /* conversion stuff */
3692
    UINT decl_change_count, full_conversion_count;
3693 3694 3695
    UINT draw_count;
    UINT stride;                                            /* 0 if no conversion */
    enum wined3d_buffer_conversion_type *conversion_map;    /* NULL if no conversion */
3696
    UINT conversion_stride;                                 /* 0 if no shifted conversion */
3697 3698
};

3699 3700 3701 3702 3703
static inline struct wined3d_buffer *buffer_from_resource(struct wined3d_resource *resource)
{
    return CONTAINING_RECORD(resource, struct wined3d_buffer, resource);
}

3704
DWORD wined3d_buffer_get_memory(struct wined3d_buffer *buffer,
3705
        struct wined3d_bo_address *data, DWORD locations) DECLSPEC_HIDDEN;
3706
void wined3d_buffer_invalidate_location(struct wined3d_buffer *buffer, DWORD location) DECLSPEC_HIDDEN;
3707 3708
void wined3d_buffer_load(struct wined3d_buffer *buffer, struct wined3d_context *context,
        const struct wined3d_state *state) DECLSPEC_HIDDEN;
3709 3710
BOOL wined3d_buffer_load_location(struct wined3d_buffer *buffer,
        struct wined3d_context *context, DWORD location) DECLSPEC_HIDDEN;
3711
BYTE *wined3d_buffer_load_sysmem(struct wined3d_buffer *buffer, struct wined3d_context *context) DECLSPEC_HIDDEN;
3712
void wined3d_buffer_copy(struct wined3d_buffer *dst_buffer, unsigned int dst_offset,
3713
        struct wined3d_buffer *src_buffer, unsigned int src_offset, unsigned int size) DECLSPEC_HIDDEN;
3714
void wined3d_buffer_upload_data(struct wined3d_buffer *buffer, struct wined3d_context *context,
3715
        const struct wined3d_box *box, const void *data) DECLSPEC_HIDDEN;
3716

3717 3718 3719 3720
struct wined3d_rendertarget_view
{
    LONG refcount;

3721
    struct wined3d_resource *resource;
3722
    void *parent;
3723
    const struct wined3d_parent_ops *parent_ops;
3724

3725
    struct wined3d_gl_view gl_view;
3726
    const struct wined3d_format *format;
3727
    unsigned int format_flags;
3728
    unsigned int sub_resource_idx;
3729
    unsigned int layer_count;
3730 3731 3732

    unsigned int width;
    unsigned int height;
3733 3734

    struct wined3d_view_desc desc;
3735 3736
};

3737 3738
void wined3d_rendertarget_view_get_drawable_size(const struct wined3d_rendertarget_view *view,
        const struct wined3d_context *context, unsigned int *width, unsigned int *height) DECLSPEC_HIDDEN;
3739 3740
void wined3d_rendertarget_view_invalidate_location(struct wined3d_rendertarget_view *view,
        DWORD location) DECLSPEC_HIDDEN;
3741 3742
void wined3d_rendertarget_view_load_location(struct wined3d_rendertarget_view *view,
        struct wined3d_context *context, DWORD location) DECLSPEC_HIDDEN;
3743 3744
void wined3d_rendertarget_view_prepare_location(struct wined3d_rendertarget_view *view,
        struct wined3d_context *context, DWORD location) DECLSPEC_HIDDEN;
3745 3746
void wined3d_rendertarget_view_validate_location(struct wined3d_rendertarget_view *view,
        DWORD location) DECLSPEC_HIDDEN;
3747

3748 3749 3750 3751
struct wined3d_shader_resource_view
{
    LONG refcount;

3752
    struct wined3d_resource *resource;
3753 3754
    void *parent;
    const struct wined3d_parent_ops *parent_ops;
3755

3756
    struct wined3d_gl_view gl_view;
3757 3758
    const struct wined3d_format *format;

3759
    struct wined3d_view_desc desc;
3760 3761
};

3762
void shader_resource_view_generate_mipmaps(struct wined3d_shader_resource_view *view) DECLSPEC_HIDDEN;
3763 3764
void wined3d_shader_resource_view_bind(struct wined3d_shader_resource_view *view, unsigned int unit,
        struct wined3d_sampler *sampler, struct wined3d_context *context) DECLSPEC_HIDDEN;
3765

3766 3767 3768 3769 3770 3771 3772 3773
struct wined3d_unordered_access_view
{
    LONG refcount;

    struct wined3d_resource *resource;
    void *parent;
    const struct wined3d_parent_ops *parent_ops;

3774
    struct wined3d_gl_view gl_view;
3775
    const struct wined3d_format *format;
3776
    GLuint counter_bo;
3777 3778

    struct wined3d_view_desc desc;
3779 3780
};

3781 3782
void wined3d_unordered_access_view_clear_uint(struct wined3d_unordered_access_view *view,
        const struct wined3d_uvec4 *clear_value, struct wined3d_context *context) DECLSPEC_HIDDEN;
3783 3784
void wined3d_unordered_access_view_copy_counter(struct wined3d_unordered_access_view *view,
        struct wined3d_buffer *buffer, unsigned int offset, struct wined3d_context *context) DECLSPEC_HIDDEN;
3785 3786
void wined3d_unordered_access_view_invalidate_location(struct wined3d_unordered_access_view *view,
        DWORD location) DECLSPEC_HIDDEN;
3787 3788
void wined3d_unordered_access_view_set_counter(struct wined3d_unordered_access_view *view,
        unsigned int value) DECLSPEC_HIDDEN;
3789

3790 3791
struct wined3d_swapchain_ops
{
3792 3793
    void (*swapchain_present)(struct wined3d_swapchain *swapchain,
            const RECT *src_rect, const RECT *dst_rect, DWORD flags);
3794
    void (*swapchain_frontbuffer_updated)(struct wined3d_swapchain *swapchain);
3795
};
Oliver Stieber's avatar
Oliver Stieber committed
3796

3797
struct wined3d_swapchain
Oliver Stieber's avatar
Oliver Stieber committed
3798
{
3799
    LONG ref;
3800
    void *parent;
3801
    const struct wined3d_parent_ops *parent_ops;
3802
    const struct wined3d_swapchain_ops *swapchain_ops;
3803
    struct wined3d_device *device;
Oliver Stieber's avatar
Oliver Stieber committed
3804

3805
    struct wined3d_texture **back_buffers;
3806
    struct wined3d_texture *front_buffer;
3807
    struct wined3d_swapchain_desc desc;
3808
    struct wined3d_display_mode original_mode, d3d_mode;
3809
    RECT original_window_rect;
3810
    struct wined3d_gamma_ramp orig_gamma;
3811
    BOOL render_to_fbo, reapply_mode;
3812
    const struct wined3d_format *ds_format;
3813
    struct wined3d_palette *palette;
3814
    RECT front_buffer_update;
3815
    unsigned int swap_interval;
3816
    unsigned int max_frame_latency;
Oliver Stieber's avatar
Oliver Stieber committed
3817

3818
    LONG prev_time, frames;   /* Performance tracking */
3819

3820
    struct wined3d_context **context;
3821
    unsigned int num_contexts;
Oliver Stieber's avatar
Oliver Stieber committed
3822

3823
    HWND win_handle;
3824
    HWND device_window;
3825 3826 3827

    HDC backup_dc;
    HWND backup_wnd;
3828
};
Oliver Stieber's avatar
Oliver Stieber committed
3829

3830
void wined3d_swapchain_activate(struct wined3d_swapchain *swapchain, BOOL activate) DECLSPEC_HIDDEN;
3831 3832
void wined3d_swapchain_set_swap_interval(struct wined3d_swapchain *swapchain,
        unsigned int swap_interval) DECLSPEC_HIDDEN;
3833
struct wined3d_context *swapchain_get_context(struct wined3d_swapchain *swapchain) DECLSPEC_HIDDEN;
3834
void swapchain_destroy_contexts(struct wined3d_swapchain *swapchain) DECLSPEC_HIDDEN;
3835
HDC swapchain_get_backup_dc(struct wined3d_swapchain *swapchain) DECLSPEC_HIDDEN;
3836
void swapchain_update_draw_bindings(struct wined3d_swapchain *swapchain) DECLSPEC_HIDDEN;
3837 3838
void swapchain_set_max_frame_latency(struct wined3d_swapchain *swapchain,
        const struct wined3d_device *device) DECLSPEC_HIDDEN;
3839

3840
/*****************************************************************************
3841
 * Utility function prototypes
3842
 */
3843 3844

/* Trace routines */
3845
const char *debug_box(const struct wined3d_box *box) DECLSPEC_HIDDEN;
3846
const char *debug_color(const struct wined3d_color *color) DECLSPEC_HIDDEN;
3847
const char *debug_d3dshaderinstructionhandler(enum WINED3D_SHADER_INSTRUCTION_HANDLER handler_idx) DECLSPEC_HIDDEN;
3848
const char *debug_d3dformat(enum wined3d_format_id format_id) DECLSPEC_HIDDEN;
3849
const char *debug_d3ddevicetype(enum wined3d_device_type device_type) DECLSPEC_HIDDEN;
3850
const char *debug_d3dresourcetype(enum wined3d_resource_type resource_type) DECLSPEC_HIDDEN;
3851 3852
const char *debug_d3dusage(DWORD usage) DECLSPEC_HIDDEN;
const char *debug_d3dusagequery(DWORD usagequery) DECLSPEC_HIDDEN;
3853
const char *debug_d3ddeclmethod(enum wined3d_decl_method method) DECLSPEC_HIDDEN;
3854
const char *debug_d3ddeclusage(enum wined3d_decl_usage usage) DECLSPEC_HIDDEN;
3855
const char *debug_d3dinput_classification(enum wined3d_input_classification classification) DECLSPEC_HIDDEN;
3856
const char *debug_d3dprimitivetype(enum wined3d_primitive_type primitive_type) DECLSPEC_HIDDEN;
3857
const char *debug_d3drenderstate(enum wined3d_render_state state) DECLSPEC_HIDDEN;
3858
const char *debug_d3dsamplerstate(enum wined3d_sampler_state state) DECLSPEC_HIDDEN;
3859
const char *debug_d3dstate(DWORD state) DECLSPEC_HIDDEN;
3860
const char *debug_d3dtexturefiltertype(enum wined3d_texture_filter_type filter_type) DECLSPEC_HIDDEN;
3861
const char *debug_d3dtexturestate(enum wined3d_texture_stage_state state) DECLSPEC_HIDDEN;
3862
const char *debug_d3dtop(enum wined3d_texture_op d3dtop) DECLSPEC_HIDDEN;
3863
const char *debug_d3dtstype(enum wined3d_transform_state tstype) DECLSPEC_HIDDEN;
3864
const char *debug_fboattachment(GLenum attachment) DECLSPEC_HIDDEN;
3865 3866
const char *debug_fbostatus(GLenum status) DECLSPEC_HIDDEN;
const char *debug_glerror(GLenum error) DECLSPEC_HIDDEN;
3867
const char *debug_ivec4(const struct wined3d_ivec4 *v) DECLSPEC_HIDDEN;
3868
const char *debug_uvec4(const struct wined3d_uvec4 *v) DECLSPEC_HIDDEN;
3869
const char *debug_shader_type(enum wined3d_shader_type shader_type) DECLSPEC_HIDDEN;
3870
const char *debug_vec4(const struct wined3d_vec4 *v) DECLSPEC_HIDDEN;
3871
void dump_color_fixup_desc(struct color_fixup_desc fixup) DECLSPEC_HIDDEN;
3872

3873
BOOL is_invalid_op(const struct wined3d_state *state, int stage,
3874
        enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3) DECLSPEC_HIDDEN;
3875
void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d_state *state,
3876
        BOOL is_alpha, int stage, enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3,
3877
        INT texture_idx, DWORD dst) DECLSPEC_HIDDEN;
3878
void texture_activate_dimensions(const struct wined3d_texture *texture,
3879
        const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
3880 3881 3882 3883 3884 3885
void sampler_texdim(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
void tex_alphaop(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
void apply_pixelshader(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
3886 3887
void state_alpha_test(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
3888 3889 3890 3891 3892 3893 3894 3895
void state_fogcolor(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
void state_fogdensity(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
void state_fogstartend(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
void state_fog_fragpart(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
3896 3897
void state_nop(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
3898 3899
void state_srgbwrite(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
3900

3901 3902 3903 3904 3905 3906 3907 3908
void state_clipping(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
void clipplane(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
void state_pointsprite_w(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
void state_pointsprite(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
3909 3910
void state_shademode(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
3911

3912
GLenum gl_primitive_type_from_d3d(enum wined3d_primitive_type primitive_type) DECLSPEC_HIDDEN;
3913
enum wined3d_primitive_type d3d_primitive_type_from_gl(GLenum primitive_type) DECLSPEC_HIDDEN;
3914

3915
/* Math utils */
3916 3917
void multiply_matrix(struct wined3d_matrix *dest, const struct wined3d_matrix *src1,
        const struct wined3d_matrix *src2) DECLSPEC_HIDDEN;
3918

3919 3920
void wined3d_release_dc(HWND window, HDC dc) DECLSPEC_HIDDEN;

3921 3922
struct wined3d_shader_lconst
{
3923 3924 3925
    struct list entry;
    unsigned int idx;
    DWORD value[4];
3926
};
3927

3928 3929
struct wined3d_shader_limits
{
3930
    unsigned int sampler;
3931 3932 3933
    unsigned int constant_int;
    unsigned int constant_float;
    unsigned int constant_bool;
3934 3935
    unsigned int packed_output;
    unsigned int packed_input;
3936
};
3937

3938 3939 3940 3941 3942 3943
#ifdef __GNUC__
#define PRINTF_ATTR(fmt,args) __attribute__((format (printf,fmt,args)))
#else
#define PRINTF_ATTR(fmt,args)
#endif

3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954
struct wined3d_string_buffer_list
{
    struct list list;
};

struct wined3d_string_buffer *string_buffer_get(struct wined3d_string_buffer_list *list) DECLSPEC_HIDDEN;
void string_buffer_sprintf(struct wined3d_string_buffer *buffer, const char *format, ...) PRINTF_ATTR(2, 3) DECLSPEC_HIDDEN;
void string_buffer_release(struct wined3d_string_buffer_list *list, struct wined3d_string_buffer *buffer) DECLSPEC_HIDDEN;
void string_buffer_list_init(struct wined3d_string_buffer_list *list) DECLSPEC_HIDDEN;
void string_buffer_list_cleanup(struct wined3d_string_buffer_list *list) DECLSPEC_HIDDEN;

3955
int shader_addline(struct wined3d_string_buffer *buffer, const char *fmt, ...) PRINTF_ATTR(2,3) DECLSPEC_HIDDEN;
3956
BOOL string_buffer_resize(struct wined3d_string_buffer *buffer, int rc) DECLSPEC_HIDDEN;
3957
int shader_vaddline(struct wined3d_string_buffer *buffer, const char *fmt, va_list args) DECLSPEC_HIDDEN;
3958

3959 3960 3961 3962
struct wined3d_shader_phase
{
    const DWORD *start;
    const DWORD *end;
3963
    unsigned int instance_count;
3964
    unsigned int temporary_count;
3965
};
3966

3967 3968 3969 3970 3971
struct wined3d_vertex_shader
{
    struct wined3d_shader_attribute attributes[MAX_ATTRIBS];
};

3972 3973
struct wined3d_hull_shader
{
3974 3975 3976 3977 3978 3979 3980 3981 3982 3983
    struct
    {
        struct wined3d_shader_phase *control_point;
        unsigned int fork_count;
        unsigned int join_count;
        struct wined3d_shader_phase *fork;
        SIZE_T fork_size;
        struct wined3d_shader_phase *join;
        SIZE_T join_size;
    } phases;
3984
    unsigned int output_vertex_count;
3985 3986 3987 3988
    enum wined3d_tessellator_output_primitive tessellator_output_primitive;
    enum wined3d_tessellator_partitioning tessellator_partitioning;
};

3989 3990 3991 3992 3993
struct wined3d_domain_shader
{
    enum wined3d_tessellator_domain tessellator_domain;
};

3994 3995 3996 3997
struct wined3d_geometry_shader
{
    enum wined3d_primitive_type input_type;
    enum wined3d_primitive_type output_type;
3998 3999
    unsigned int vertices_out;
    unsigned int instance_count;
4000 4001

    struct wined3d_stream_output_desc so_desc;
4002 4003
};

4004 4005 4006 4007
struct wined3d_pixel_shader
{
    /* Pixel shader input semantics */
    DWORD input_reg_map[MAX_REG_INPUT];
4008
    DWORD input_reg_used; /* MAX_REG_INPUT, 32 */
4009 4010 4011 4012 4013
    unsigned int declared_in_count;

    /* Some information about the shader behavior */
    BOOL color0_mov;
    DWORD color0_reg;
4014 4015

    BOOL force_early_depth_stencil;
4016
    enum wined3d_shader_register_type depth_output;
4017
    DWORD interpolation_mode[WINED3D_PACKED_INTERPOLATION_SIZE];
4018 4019
};

4020 4021 4022 4023 4024
struct wined3d_compute_shader
{
    struct wined3d_shader_thread_group_size thread_group_size;
};

4025 4026
struct wined3d_shader
{
4027
    LONG ref;
4028
    const struct wined3d_shader_limits *limits;
4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046
    DWORD *function;
    UINT functionLength;
    BOOL load_local_constsF;
    const struct wined3d_shader_frontend *frontend;
    void *frontend_data;
    void *backend_data;

    void *parent;
    const struct wined3d_parent_ops *parent_ops;

    /* Programs this shader is linked with */
    struct list linked_programs;

    /* Immediate constants (override global ones) */
    struct list constantsB;
    struct list constantsF;
    struct list constantsI;
    struct wined3d_shader_reg_maps reg_maps;
4047
    BOOL lconst_inf_or_nan;
4048

4049
    struct wined3d_shader_signature input_signature;
4050
    struct wined3d_shader_signature output_signature;
4051
    struct wined3d_shader_signature patch_constant_signature;
4052
    char *signature_strings;
4053 4054

    /* Pointer to the parent device */
4055
    struct wined3d_device *device;
4056
    struct list shader_list_entry;
4057 4058 4059 4060

    union
    {
        struct wined3d_vertex_shader vs;
4061
        struct wined3d_hull_shader hs;
4062
        struct wined3d_domain_shader ds;
4063
        struct wined3d_geometry_shader gs;
4064
        struct wined3d_pixel_shader ps;
4065
        struct wined3d_compute_shader cs;
4066
    } u;
4067
};
4068

4069
void pixelshader_update_resource_types(struct wined3d_shader *shader, WORD tex_types) DECLSPEC_HIDDEN;
4070 4071
void find_ps_compile_args(const struct wined3d_state *state, const struct wined3d_shader *shader,
        BOOL position_transformed, struct ps_compile_args *args,
4072
        const struct wined3d_context *context) DECLSPEC_HIDDEN;
4073

4074 4075
BOOL vshader_get_input(const struct wined3d_shader *shader,
        BYTE usage_req, BYTE usage_idx_req, unsigned int *regnum) DECLSPEC_HIDDEN;
4076
void find_vs_compile_args(const struct wined3d_state *state, const struct wined3d_shader *shader,
4077
        WORD swizzle_map, struct vs_compile_args *args,
4078
        const struct wined3d_context *context) DECLSPEC_HIDDEN;
4079

4080 4081 4082
void find_ds_compile_args(const struct wined3d_state *state, const struct wined3d_shader *shader,
        struct ds_compile_args *args, const struct wined3d_context *context) DECLSPEC_HIDDEN;

4083
void find_gs_compile_args(const struct wined3d_state *state, const struct wined3d_shader *shader,
4084
        struct gs_compile_args *args, const struct wined3d_context *context) DECLSPEC_HIDDEN;
4085

4086 4087 4088
void string_buffer_clear(struct wined3d_string_buffer *buffer) DECLSPEC_HIDDEN;
BOOL string_buffer_init(struct wined3d_string_buffer *buffer) DECLSPEC_HIDDEN;
void string_buffer_free(struct wined3d_string_buffer *buffer) DECLSPEC_HIDDEN;
4089 4090
unsigned int shader_find_free_input_register(const struct wined3d_shader_reg_maps *reg_maps,
        unsigned int max) DECLSPEC_HIDDEN;
4091 4092 4093
HRESULT shader_generate_code(const struct wined3d_shader *shader, struct wined3d_string_buffer *buffer,
        const struct wined3d_shader_reg_maps *reg_maps, void *backend_ctx,
        const DWORD *start, const DWORD *end) DECLSPEC_HIDDEN;
4094
BOOL shader_match_semantic(const char *semantic_name, enum wined3d_decl_usage usage) DECLSPEC_HIDDEN;
4095

4096
static inline BOOL shader_is_scalar(const struct wined3d_shader_register *reg)
4097
{
4098
    switch (reg->type)
4099
    {
4100
        case WINED3DSPR_RASTOUT:
4101
            /* oFog & oPts */
4102 4103
            if (reg->idx[0].offset)
                return TRUE;
4104 4105 4106
            /* oPos */
            return FALSE;

4107
        case WINED3DSPR_CONSTBOOL:  /* b# */
4108
        case WINED3DSPR_DEPTHOUT:   /* oDepth */
4109 4110
        case WINED3DSPR_DEPTHOUTGE:
        case WINED3DSPR_DEPTHOUTLE:
4111 4112
        case WINED3DSPR_LOOP:       /* aL */
        case WINED3DSPR_PREDICATE:  /* p0 */
4113
        case WINED3DSPR_PRIMID:     /* primID */
4114
        case WINED3DSPR_SAMPLEMASK: /* oMask */
4115 4116
            return TRUE;

4117
        case WINED3DSPR_MISCTYPE:
4118
            switch (reg->idx[0].offset)
4119
            {
4120 4121 4122 4123 4124 4125 4126 4127
                case 0: /* vPos */
                    return FALSE;
                case 1: /* vFace */
                    return TRUE;
                default:
                    return FALSE;
            }

4128
        case WINED3DSPR_IMMCONST:
4129
            return reg->immconst_type == WINED3D_IMMCONST_SCALAR;
4130

4131 4132 4133 4134 4135
        default:
            return FALSE;
    }
}

4136
static inline void shader_get_position_fixup(const struct wined3d_context *context,
4137
        const struct wined3d_state *state, unsigned int fixup_count, float *position_fixup)
4138
{
4139
    float center_offset;
4140
    unsigned int i;
4141

4142
    if (context->d3d_info->wined3d_creation_flags & WINED3D_PIXEL_CENTER_INTEGER)
4143 4144 4145 4146
        center_offset = 63.0f / 64.0f;
    else
        center_offset = -1.0f / 64.0f;

4147
    for (i = 0; i < fixup_count; ++i)
4148
    {
4149 4150 4151 4152 4153 4154 4155 4156 4157 4158
        position_fixup[4 * i    ] = 1.0f;
        position_fixup[4 * i + 1] = 1.0f;
        position_fixup[4 * i + 2] = center_offset / state->viewports[i].width;
        position_fixup[4 * i + 3] = -center_offset / state->viewports[i].height;

        if (context->render_offscreen)
        {
            position_fixup[4 * i + 1] *= -1.0f;
            position_fixup[4 * i + 3] *= -1.0f;
        }
4159 4160 4161
    }
}

4162
static inline BOOL shader_constant_is_local(const struct wined3d_shader *shader, DWORD reg)
4163
{
4164
    struct wined3d_shader_lconst *lconst;
4165 4166 4167

    if (shader->load_local_constsF)
        return FALSE;
4168

4169
    LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, struct wined3d_shader_lconst, entry)
4170 4171 4172
    {
        if (lconst->idx == reg)
            return TRUE;
4173 4174
    }

4175
    return FALSE;
4176 4177
}

4178
void get_identity_matrix(struct wined3d_matrix *mat) DECLSPEC_HIDDEN;
4179
void get_modelview_matrix(const struct wined3d_context *context, const struct wined3d_state *state,
4180
        unsigned int index, struct wined3d_matrix *mat) DECLSPEC_HIDDEN;
4181 4182
void get_projection_matrix(const struct wined3d_context *context, const struct wined3d_state *state,
        struct wined3d_matrix *mat) DECLSPEC_HIDDEN;
4183 4184
void get_texture_matrix(const struct wined3d_context *context, const struct wined3d_state *state,
        unsigned int tex, struct wined3d_matrix *mat) DECLSPEC_HIDDEN;
4185 4186
void get_pointsize_minmax(const struct wined3d_context *context, const struct wined3d_state *state,
        float *out_min, float *out_max) DECLSPEC_HIDDEN;
4187 4188
void get_pointsize(const struct wined3d_context *context, const struct wined3d_state *state,
        float *out_pointsize, float *out_att) DECLSPEC_HIDDEN;
4189 4190
void get_fog_start_end(const struct wined3d_context *context, const struct wined3d_state *state,
        float *start, float *end) DECLSPEC_HIDDEN;
4191

4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208
/* Using additional shader constants (uniforms in GLSL / program environment
 * or local parameters in ARB) is costly:
 * ARB only knows float4 parameters and GLSL compiler are not really smart
 * when it comes to efficiently pack float2 uniforms, so no space is wasted
 * (in fact most compilers map a float2 to a full float4 uniform).
 *
 * For NP2 texcoord fixup we only need 2 floats (width and height) for each
 * 2D texture used in the shader. We therefore pack fixup info for 2 textures
 * into a single shader constant (uniform / program parameter).
 *
 * This structure is shared between the GLSL and the ARB backend.*/
struct ps_np2fixup_info {
    unsigned char     idx[MAX_FRAGMENT_SAMPLERS]; /* indices to the real constant */
    WORD              active; /* bitfield indicating if we can apply the fixup */
    WORD              num_consts;
};

4209 4210 4211
void print_glsl_info_log(const struct wined3d_gl_info *gl_info, GLuint id, BOOL program) DECLSPEC_HIDDEN;
void shader_glsl_validate_link(const struct wined3d_gl_info *gl_info, GLuint program) DECLSPEC_HIDDEN;

4212 4213 4214
struct wined3d_palette
{
    LONG ref;
4215
    struct wined3d_device *device;
4216

4217
    unsigned int size;
4218
    RGBQUAD colors[256];
4219
    DWORD flags;
4220 4221
};

4222
/* DirectDraw utility functions */
4223
extern enum wined3d_format_id pixelformat_for_depth(DWORD depth) DECLSPEC_HIDDEN;
4224

4225 4226 4227
/*****************************************************************************
 * Pixel format management
 */
4228

4229
/* WineD3D pixel format flags */
4230 4231 4232 4233 4234
#define WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING    0x00000001
#define WINED3DFMT_FLAG_FILTERING                   0x00000002
#define WINED3DFMT_FLAG_DEPTH                       0x00000004
#define WINED3DFMT_FLAG_STENCIL                     0x00000008
#define WINED3DFMT_FLAG_RENDERTARGET                0x00000010
4235
#define WINED3DFMT_FLAG_EXTENSION                   0x00000020
4236
#define WINED3DFMT_FLAG_FBO_ATTACHABLE              0x00000040
4237
#define WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB         0x00000080
4238
#define WINED3DFMT_FLAG_DECOMPRESS                  0x00000100
4239 4240
#define WINED3DFMT_FLAG_FLOAT                       0x00000200
#define WINED3DFMT_FLAG_BUMPMAP                     0x00000400
4241
#define WINED3DFMT_FLAG_SRGB_READ                   0x00000800
4242
#define WINED3DFMT_FLAG_SRGB_WRITE                  0x00001000
4243
#define WINED3DFMT_FLAG_VTF                         0x00002000
4244
#define WINED3DFMT_FLAG_SHADOW                      0x00004000
4245
#define WINED3DFMT_FLAG_COMPRESSED                  0x00008000
4246
#define WINED3DFMT_FLAG_BROKEN_PITCH                0x00010000
4247
#define WINED3DFMT_FLAG_BLOCKS                      0x00020000
4248
#define WINED3DFMT_FLAG_HEIGHT_SCALE                0x00040000
4249
#define WINED3DFMT_FLAG_TEXTURE                     0x00080000
4250
#define WINED3DFMT_FLAG_BLOCKS_NO_VERIFY            0x00100000
4251
#define WINED3DFMT_FLAG_INTEGER                     0x00200000
4252
#define WINED3DFMT_FLAG_GEN_MIPMAP                  0x00400000
4253

4254 4255 4256 4257 4258 4259
struct wined3d_rational
{
    UINT numerator;
    UINT denominator;
};

4260 4261 4262
struct wined3d_color_key_conversion
{
    enum wined3d_format_id dst_format;
4263 4264
    void (*convert)(const BYTE *src, unsigned int src_pitch, BYTE *dst, unsigned int dst_pitch,
            unsigned int width, unsigned int height, const struct wined3d_color_key *colour_key);
4265 4266
};

4267
struct wined3d_format
4268
{
4269 4270
    enum wined3d_format_id id;

4271
    D3DDDIFORMAT ddi_format;
4272 4273 4274 4275 4276 4277 4278 4279
    DWORD red_size;
    DWORD green_size;
    DWORD blue_size;
    DWORD alpha_size;
    DWORD red_offset;
    DWORD green_offset;
    DWORD blue_offset;
    DWORD alpha_offset;
4280
    UINT byte_count;
4281 4282
    BYTE depth_size;
    BYTE stencil_size;
4283

4284 4285 4286 4287
    UINT block_width;
    UINT block_height;
    UINT block_byte_count;

4288 4289 4290 4291 4292
    enum wined3d_ffp_emit_idx emit_idx;
    GLint component_count;
    GLenum gl_vtx_type;
    GLint gl_vtx_format;
    GLboolean gl_normalized;
4293
    unsigned int attribute_size;
4294

4295 4296 4297 4298 4299
    GLint glInternal;
    GLint glGammaInternal;
    GLint rtInternal;
    GLint glFormat;
    GLint glType;
4300
    UINT  conv_byte_count;
4301
    DWORD multisample_types;
4302
    unsigned int flags[WINED3D_GL_RES_TYPE_COUNT];
4303
    float depth_bias_scale;
4304
    struct wined3d_rational height_scale;
4305
    struct color_fixup_desc color_fixup;
4306 4307 4308 4309 4310 4311
    void (*upload)(const BYTE *src, BYTE *dst, unsigned int src_row_pitch, unsigned int src_slice_pitch,
            unsigned int dst_row_pitch, unsigned dst_slice_pitch,
            unsigned int width, unsigned int height, unsigned int depth);
    void (*download)(const BYTE *src, BYTE *dst, unsigned int src_row_pitch, unsigned int src_slice_pitch,
            unsigned int dst_row_pitch, unsigned dst_slice_pitch,
            unsigned int width, unsigned int height, unsigned int depth);
4312 4313 4314
    void (*decompress)(const BYTE *src, BYTE *dst, unsigned int src_row_pitch, unsigned int src_slice_pitch,
            unsigned int dst_row_pitch, unsigned dst_slice_pitch,
            unsigned int width, unsigned int height, unsigned int depth);
4315

4316
    enum wined3d_format_id typeless_id;
4317
    GLenum gl_view_class;
4318 4319
};

4320
const struct wined3d_format *wined3d_get_format(const struct wined3d_gl_info *gl_info,
4321
        enum wined3d_format_id format_id, unsigned int resource_usage) DECLSPEC_HIDDEN;
4322 4323
void wined3d_format_calculate_pitch(const struct wined3d_format *format, unsigned int alignment,
        unsigned int width, unsigned int height, unsigned int *row_pitch, unsigned int *slice_pitch) DECLSPEC_HIDDEN;
4324
UINT wined3d_format_calculate_size(const struct wined3d_format *format,
4325
        UINT alignment, UINT width, UINT height, UINT depth) DECLSPEC_HIDDEN;
4326
DWORD wined3d_format_convert_from_float(const struct wined3d_format *format,
4327
        const struct wined3d_color *color) DECLSPEC_HIDDEN;
4328 4329
void wined3d_format_get_float_color_key(const struct wined3d_format *format,
        const struct wined3d_color_key *key, struct wined3d_color *float_colors) DECLSPEC_HIDDEN;
4330 4331
BOOL wined3d_format_is_depth_view(enum wined3d_format_id resource_format_id,
        enum wined3d_format_id view_format_id) DECLSPEC_HIDDEN;
4332 4333
const struct wined3d_color_key_conversion * wined3d_format_get_color_key_conversion(
        const struct wined3d_texture *texture, BOOL need_alpha_ck) DECLSPEC_HIDDEN;
4334 4335
BOOL wined3d_formats_are_srgb_variants(enum wined3d_format_id format1,
        enum wined3d_format_id format2) DECLSPEC_HIDDEN;
4336

4337 4338
BOOL wined3d_array_reserve(void **elements, SIZE_T *capacity, SIZE_T count, SIZE_T size) DECLSPEC_HIDDEN;

4339 4340 4341 4342 4343
static inline BOOL wined3d_format_is_typeless(const struct wined3d_format *format)
{
    return format->id == format->typeless_id && format->id != WINED3DFMT_UNKNOWN;
}

4344
static inline BOOL use_vs(const struct wined3d_state *state)
4345
{
4346 4347
    /* Check state->vertex_declaration to allow this to be used before the
     * stream info is validated, for example in device_update_tex_unit_map(). */
4348 4349
    return state->shader[WINED3D_SHADER_TYPE_VERTEX]
            && (!state->vertex_declaration || !state->vertex_declaration->position_transformed);
4350 4351
}

4352
static inline BOOL use_ps(const struct wined3d_state *state)
4353
{
4354
    return !!state->shader[WINED3D_SHADER_TYPE_PIXEL];
4355 4356
}

4357 4358 4359
static inline void context_apply_state(struct wined3d_context *context,
        const struct wined3d_state *state, DWORD state_id)
{
4360 4361 4362
    const struct StateEntry *state_table = context->state_table;
    DWORD rep = state_table[state_id].representative;
    state_table[rep].apply(context, state, rep);
4363 4364
}

4365 4366 4367
static inline BOOL needs_separate_srgb_gl_texture(const struct wined3d_context *context,
        const struct wined3d_texture *texture)
{
4368 4369
    unsigned int flags = texture->resource.format_flags
            & (WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE);
4370 4371

    return (!context->gl_info->supported[EXT_TEXTURE_SRGB_DECODE]
4372
            || (flags && flags != (WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE)))
4373 4374 4375
            && context->d3d_info->wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL;
}

4376 4377 4378 4379 4380
static inline BOOL needs_srgb_write(const struct wined3d_context *context,
        const struct wined3d_state *state, const struct wined3d_fb_state *fb)
{
    return (!(context->d3d_info->wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL)
            || state->render_states[WINED3D_RS_SRGBWRITEENABLE])
4381
            && fb->render_targets[0] && fb->render_targets[0]->format_flags & WINED3DFMT_FLAG_SRGB_WRITE;
4382 4383
}

4384
static inline GLuint wined3d_texture_get_texture_name(const struct wined3d_texture *texture,
4385 4386
        const struct wined3d_context *context, BOOL srgb)
{
4387 4388
    return srgb && needs_separate_srgb_gl_texture(context, texture)
            ? texture->texture_srgb.name : texture->texture_rgb.name;
4389 4390
}

4391 4392 4393 4394 4395 4396
static inline BOOL can_use_texture_swizzle(const struct wined3d_gl_info *gl_info, const struct wined3d_format *format)
{
    return gl_info->supported[ARB_TEXTURE_SWIZZLE] && !is_complex_fixup(format->color_fixup)
            && !is_scaling_fixup(format->color_fixup);
}

4397 4398 4399 4400 4401 4402 4403 4404 4405
static inline BOOL needs_interpolation_qualifiers_for_shader_outputs(const struct wined3d_gl_info *gl_info)
{
    /* In GLSL 4.40+ it is fine to specify interpolation qualifiers only in
     * fragment shaders. In older GLSL versions interpolation qualifiers must
     * match between shader stages.
     */
    return gl_info->glsl_version < MAKEDWORD_VERSION(4, 40);
}

4406 4407 4408 4409 4410 4411
static inline BOOL is_rasterization_disabled(const struct wined3d_shader *geometry_shader)
{
    return geometry_shader
            && geometry_shader->u.gs.so_desc.rasterizer_stream_idx == WINED3D_NO_RASTERIZER_STREAM;
}

4412 4413 4414 4415 4416 4417 4418
static inline int wined3d_bit_scan(unsigned int *x)
{
    int bit_offset = ffs(*x) - 1;
    *x ^= 1u << bit_offset;
    return bit_offset;
}

4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456
static inline DWORD wined3d_extract_bits(const DWORD *bitstream,
        unsigned int offset, unsigned int count)
{
    const unsigned int word_bit_count = sizeof(*bitstream) * CHAR_BIT;
    const unsigned int idx = offset / word_bit_count;
    const unsigned int shift = offset % word_bit_count;
    DWORD mask = (1u << count) - 1;
    DWORD ret;

    ret = (bitstream[idx] >> shift) & mask;
    if (shift + count > word_bit_count)
    {
        const unsigned int extracted_bit_count = word_bit_count - shift;
        const unsigned int remaining_bit_count = count - extracted_bit_count;
        mask = (1u << remaining_bit_count) - 1;
        ret |= (bitstream[idx + 1] & mask) << extracted_bit_count;
    }
    return ret;
}

static inline void wined3d_insert_bits(DWORD *bitstream,
        unsigned int offset, unsigned int count, DWORD bits)
{
    const unsigned int word_bit_count = sizeof(*bitstream) * CHAR_BIT;
    const unsigned int idx = offset / word_bit_count;
    const unsigned int shift = offset % word_bit_count;
    DWORD mask = (1u << count) - 1;

    bitstream[idx] |= (bits & mask) << shift;
    if (shift + count > word_bit_count)
    {
        const unsigned int inserted_bit_count = word_bit_count - shift;
        const unsigned int remaining_bit_count = count - inserted_bit_count;
        mask = (1u << remaining_bit_count) - 1;
        bitstream[idx + 1] |= (bits >> inserted_bit_count) & mask;
    }
}

4457
static inline void wined3d_from_cs(const struct wined3d_cs *cs)
4458 4459 4460 4461 4462 4463 4464 4465 4466 4467
{
    if (cs->thread)
        assert(cs->thread_id == GetCurrentThreadId());
}

static inline void wined3d_not_from_cs(struct wined3d_cs *cs)
{
    assert(cs->thread_id != GetCurrentThreadId());
}

4468 4469 4470
/* The WNDCLASS-Name for the fake window which we use to retrieve the GL capabilities */
#define WINED3D_OPENGL_WINDOW_CLASS_NAME "WineD3D_OpenGL"

4471
#endif