projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Update wine d3d8 and wined3d to wine release version 0.9.49
[reactos.git] / reactos / dll / directx / wine / wined3d / wined3d_private.h
1 /*
2 * Direct3D wine internal private include file
3 *
4 * Copyright 2002-2003 The wine-d3d team
5 * Copyright 2002-2003 Raphael Junqueira
6 * Copyright 2004 Jason Edmeades
7 * Copyright 2005 Oliver Stieber
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #ifndef __WINE_WINED3D_PRIVATE_H
25 #define __WINE_WINED3D_PRIVATE_H
26
27 #include <stdarg.h>
28 #include <math.h>
29 #define NONAMELESSUNION
30 #define NONAMELESSSTRUCT
31 #define COBJMACROS
32 #include "windef.h"
33 #include "winbase.h"
34 #include "winreg.h"
35 #include "wingdi.h"
36 #include "winuser.h"
37 #include "wine/debug.h"
38 #include "wine/unicode.h"
39
40 #include "wined3d_private_types.h"
41 #include "wine/wined3d_interface.h"
42 #include "wine/wined3d_caps.h"
43 #include "wine/wined3d_gl.h"
44 #include "wine/list.h"
45
46 #define ceilf(x) (float)ceil((double)x)
47 BOOL WINAPI
48 DllMain(IN HINSTANCE hinstDLL,
49 IN DWORD dwReason,
50 IN LPVOID lpvReserved);
51
52 /* Hash table functions */
53 typedef unsigned int (hash_function_t)(void *key);
54 typedef BOOL (compare_function_t)(void *keya, void *keyb);
55
56 typedef struct {
57 void *key;
58 void *value;
59 unsigned int hash;
60 struct list entry;
61 } hash_table_entry_t;
62
63 typedef struct {
64 hash_function_t *hash_function;
65 compare_function_t *compare_function;
66 struct list *buckets;
67 unsigned int bucket_count;
68 hash_table_entry_t *entries;
69 unsigned int entry_count;
70 struct list free_entries;
71 unsigned int count;
72 unsigned int grow_size;
73 unsigned int shrink_size;
74 } hash_table_t;
75
76 hash_table_t *hash_table_create(hash_function_t *hash_function, compare_function_t *compare_function);
77 void hash_table_destroy(hash_table_t *table);
78 void *hash_table_get(hash_table_t *table, void *key);
79 void hash_table_put(hash_table_t *table, void *key, void *value);
80 void hash_table_remove(hash_table_t *table, void *key);
81
82 /* Device caps */
83 #define MAX_PALETTES 256
84 #define MAX_STREAMS 16
85 #define MAX_TEXTURES 8
86 #define MAX_FRAGMENT_SAMPLERS 16
87 #define MAX_VERTEX_SAMPLERS 4
88 #define MAX_COMBINED_SAMPLERS (MAX_FRAGMENT_SAMPLERS + MAX_VERTEX_SAMPLERS)
89 #define MAX_ACTIVE_LIGHTS 8
90 #define MAX_CLIPPLANES WINED3DMAXUSERCLIPPLANES
91 #define MAX_LEVELS 256
92
93 #define MAX_CONST_I 16
94 #define MAX_CONST_B 16
95
96 /* Used for CreateStateBlock */
97 #define NUM_SAVEDPIXELSTATES_R 35
98 #define NUM_SAVEDPIXELSTATES_T 18
99 #define NUM_SAVEDPIXELSTATES_S 12
100 #define NUM_SAVEDVERTEXSTATES_R 34
101 #define NUM_SAVEDVERTEXSTATES_T 2
102 #define NUM_SAVEDVERTEXSTATES_S 1
103
104 extern const DWORD SavedPixelStates_R[NUM_SAVEDPIXELSTATES_R];
105 extern const DWORD SavedPixelStates_T[NUM_SAVEDPIXELSTATES_T];
106 extern const DWORD SavedPixelStates_S[NUM_SAVEDPIXELSTATES_S];
107 extern const DWORD SavedVertexStates_R[NUM_SAVEDVERTEXSTATES_R];
108 extern const DWORD SavedVertexStates_T[NUM_SAVEDVERTEXSTATES_T];
109 extern const DWORD SavedVertexStates_S[NUM_SAVEDVERTEXSTATES_S];
110
111 typedef enum _WINELOOKUP {
112 WINELOOKUP_WARPPARAM = 0,
113 WINELOOKUP_MAGFILTER = 1,
114 MAX_LOOKUPS = 2
115 } WINELOOKUP;
116
117 extern int minLookup[MAX_LOOKUPS];
118 extern int maxLookup[MAX_LOOKUPS];
119 extern DWORD *stateLookup[MAX_LOOKUPS];
120
121 extern DWORD minMipLookup[WINED3DTEXF_ANISOTROPIC + 1][WINED3DTEXF_LINEAR + 1];
122
123 typedef struct _WINED3DGLTYPE {
124 int d3dType;
125 GLint size;
126 GLenum glType;
127 GLboolean normalized;
128 int typesize;
129 } WINED3DGLTYPE;
130
131 /* NOTE: Make sure these are in the correct numerical order. (see /include/wined3d_types.h) */
132 static WINED3DGLTYPE const glTypeLookup[WINED3DDECLTYPE_UNUSED] = {
133 {WINED3DDECLTYPE_FLOAT1, 1, GL_FLOAT , GL_FALSE ,sizeof(float)},
134 {WINED3DDECLTYPE_FLOAT2, 2, GL_FLOAT , GL_FALSE ,sizeof(float)},
135 {WINED3DDECLTYPE_FLOAT3, 3, GL_FLOAT , GL_FALSE ,sizeof(float)},
136 {WINED3DDECLTYPE_FLOAT4, 4, GL_FLOAT , GL_FALSE ,sizeof(float)},
137 {WINED3DDECLTYPE_D3DCOLOR, 4, GL_UNSIGNED_BYTE , GL_TRUE ,sizeof(BYTE)},
138 {WINED3DDECLTYPE_UBYTE4, 4, GL_UNSIGNED_BYTE , GL_FALSE ,sizeof(BYTE)},
139 {WINED3DDECLTYPE_SHORT2, 2, GL_SHORT , GL_FALSE ,sizeof(short int)},
140 {WINED3DDECLTYPE_SHORT4, 4, GL_SHORT , GL_FALSE ,sizeof(short int)},
141 {WINED3DDECLTYPE_UBYTE4N, 4, GL_UNSIGNED_BYTE , GL_TRUE ,sizeof(BYTE)},
142 {WINED3DDECLTYPE_SHORT2N, 2, GL_SHORT , GL_TRUE ,sizeof(short int)},
143 {WINED3DDECLTYPE_SHORT4N, 4, GL_SHORT , GL_TRUE ,sizeof(short int)},
144 {WINED3DDECLTYPE_USHORT2N, 2, GL_UNSIGNED_SHORT , GL_TRUE ,sizeof(short int)},
145 {WINED3DDECLTYPE_USHORT4N, 4, GL_UNSIGNED_SHORT , GL_TRUE ,sizeof(short int)},
146 {WINED3DDECLTYPE_UDEC3, 3, GL_UNSIGNED_SHORT , GL_FALSE ,sizeof(short int)},
147 {WINED3DDECLTYPE_DEC3N, 3, GL_SHORT , GL_TRUE ,sizeof(short int)},
148 /* We should do an extension check for NV_HALF_FLOAT. However, without NV_HALF_FLOAT
149 * we won't be able to load the data at all, so at least for the moment it wouldn't
150 * gain us much. */
151 {WINED3DDECLTYPE_FLOAT16_2, 2, GL_HALF_FLOAT_NV , GL_FALSE ,sizeof(GLhalfNV)},
152 {WINED3DDECLTYPE_FLOAT16_4, 4, GL_HALF_FLOAT_NV , GL_FALSE ,sizeof(GLhalfNV)}};
153
154 #define WINED3D_ATR_TYPE(type) glTypeLookup[type].d3dType
155 #define WINED3D_ATR_SIZE(type) glTypeLookup[type].size
156 #define WINED3D_ATR_GLTYPE(type) glTypeLookup[type].glType
157 #define WINED3D_ATR_NORMALIZED(type) glTypeLookup[type].normalized
158 #define WINED3D_ATR_TYPESIZE(type) glTypeLookup[type].typesize
159
160 /**
161 * Settings
162 */
163 #define VS_NONE 0
164 #define VS_HW 1
165
166 #define PS_NONE 0
167 #define PS_HW 1
168
169 #define VBO_NONE 0
170 #define VBO_HW 1
171
172 #define NP2_NONE 0
173 #define NP2_REPACK 1
174 #define NP2_NATIVE 2
175
176 #define ORM_BACKBUFFER 0
177 #define ORM_PBUFFER 1
178 #define ORM_FBO 2
179
180 #define SHADER_ARB 1
181 #define SHADER_GLSL 2
182 #define SHADER_NONE 3
183
184 #define RTL_DISABLE -1
185 #define RTL_AUTO 0
186 #define RTL_READDRAW 1
187 #define RTL_READTEX 2
188 #define RTL_TEXDRAW 3
189 #define RTL_TEXTEX 4
190
191 /* NOTE: When adding fields to this structure, make sure to update the default
192 * values in wined3d_main.c as well. */
193 typedef struct wined3d_settings_s {
194 /* vertex and pixel shader modes */
195 int vs_mode;
196 int ps_mode;
197 int vbo_mode;
198 /* Ideally, we don't want the user to have to request GLSL. If the hardware supports GLSL,
199 we should use it. However, until it's fully implemented, we'll leave it as a registry
200 setting for developers. */
201 BOOL glslRequested;
202 int offscreen_rendering_mode;
203 int rendertargetlock_mode;
204 /* Memory tracking and object counting */
205 unsigned int emulated_textureram;
206 char *logo;
207 } wined3d_settings_t;
208
209 extern wined3d_settings_t wined3d_settings;
210
211 /* Shader backends */
212 struct SHADER_OPCODE_ARG;
213
214 typedef struct {
215 void (*shader_select)(IWineD3DDevice *iface, BOOL usePS, BOOL useVS);
216 void (*shader_select_depth_blt)(IWineD3DDevice *iface);
217 void (*shader_load_constants)(IWineD3DDevice *iface, char usePS, char useVS);
218 void (*shader_cleanup)(IWineD3DDevice *iface);
219 void (*shader_color_correction)(struct SHADER_OPCODE_ARG *arg);
220 } shader_backend_t;
221
222 extern const shader_backend_t glsl_shader_backend;
223 extern const shader_backend_t arb_program_shader_backend;
224 extern const shader_backend_t none_shader_backend;
225
226 /* X11 locking */
227
228 extern void (*wine_tsx11_lock_ptr)(void);
229 extern void (*wine_tsx11_unlock_ptr)(void);
230
231 /* As GLX relies on X, this is needed */
232 extern int num_lock;
233
234 #if 0
235 #define ENTER_GL() ++num_lock; if (num_lock > 1) FIXME("Recursive use of GL lock to: %d\n", num_lock); wine_tsx11_lock_ptr()
236 #define LEAVE_GL() if (num_lock != 1) FIXME("Recursive use of GL lock: %d\n", num_lock); --num_lock; wine_tsx11_unlock_ptr()
237 #else
238 #define ENTER_GL() wine_tsx11_lock_ptr()
239 #define LEAVE_GL() wine_tsx11_unlock_ptr()
240 #endif
241
242 /*****************************************************************************
243 * Defines
244 */
245
246 /* GL related defines */
247 /* ------------------ */
248 #define GL_SUPPORT(ExtName) (GLINFO_LOCATION.supported[ExtName] != 0)
249 #define GL_LIMITS(ExtName) (GLINFO_LOCATION.max_##ExtName)
250 #define GL_EXTCALL(FuncName) (GLINFO_LOCATION.FuncName)
251 #define GL_VEND(_VendName) (GLINFO_LOCATION.gl_vendor == VENDOR_##_VendName ? TRUE : FALSE)
252
253 #define D3DCOLOR_B_R(dw) (((dw) >> 16) & 0xFF)
254 #define D3DCOLOR_B_G(dw) (((dw) >> 8) & 0xFF)
255 #define D3DCOLOR_B_B(dw) (((dw) >> 0) & 0xFF)
256 #define D3DCOLOR_B_A(dw) (((dw) >> 24) & 0xFF)
257
258 #define D3DCOLOR_R(dw) (((float) (((dw) >> 16) & 0xFF)) / 255.0f)
259 #define D3DCOLOR_G(dw) (((float) (((dw) >> 8) & 0xFF)) / 255.0f)
260 #define D3DCOLOR_B(dw) (((float) (((dw) >> 0) & 0xFF)) / 255.0f)
261 #define D3DCOLOR_A(dw) (((float) (((dw) >> 24) & 0xFF)) / 255.0f)
262
263 #define D3DCOLORTOGLFLOAT4(dw, vec) \
264 (vec)[0] = D3DCOLOR_R(dw); \
265 (vec)[1] = D3DCOLOR_G(dw); \
266 (vec)[2] = D3DCOLOR_B(dw); \
267 (vec)[3] = D3DCOLOR_A(dw);
268
269 /* DirectX Device Limits */
270 /* --------------------- */
271 #define MAX_LEVELS 256 /* Maximum number of mipmap levels. Guessed at 256 */
272
273 #define MAX_STREAMS 16 /* Maximum possible streams - used for fixed size arrays
274 See MaxStreams in MSDN under GetDeviceCaps */
275 /* Maximum number of constants provided to the shaders */
276 #define HIGHEST_TRANSFORMSTATE 512
277 /* Highest value in WINED3DTRANSFORMSTATETYPE */
278 #define MAX_PALETTES 256
279
280 /* Checking of API calls */
281 /* --------------------- */
282 #define checkGLcall(A) \
283 { \
284 GLint err = glGetError(); \
285 if (err == GL_NO_ERROR) { \
286 TRACE("%s call ok %s / %d\n", A, __FILE__, __LINE__); \
287 \
288 } else do { \
289 FIXME(">>>>>>>>>>>>>>>>> %s (%#x) from %s @ %s / %d\n", \
290 debug_glerror(err), err, A, __FILE__, __LINE__); \
291 err = glGetError(); \
292 } while (err != GL_NO_ERROR); \
293 }
294
295 /* Trace routines / diagnostics */
296 /* ---------------------------- */
297
298 /* Dump out a matrix and copy it */
299 #define conv_mat(mat,gl_mat) \
300 do { \
301 TRACE("%f %f %f %f\n", (mat)->u.s._11, (mat)->u.s._12, (mat)->u.s._13, (mat)->u.s._14); \
302 TRACE("%f %f %f %f\n", (mat)->u.s._21, (mat)->u.s._22, (mat)->u.s._23, (mat)->u.s._24); \
303 TRACE("%f %f %f %f\n", (mat)->u.s._31, (mat)->u.s._32, (mat)->u.s._33, (mat)->u.s._34); \
304 TRACE("%f %f %f %f\n", (mat)->u.s._41, (mat)->u.s._42, (mat)->u.s._43, (mat)->u.s._44); \
305 memcpy(gl_mat, (mat), 16 * sizeof(float)); \
306 } while (0)
307
308 /* Macro to dump out the current state of the light chain */
309 #define DUMP_LIGHT_CHAIN() \
310 { \
311 PLIGHTINFOEL *el = This->stateBlock->lights;\
312 while (el) { \
313 TRACE("Light %p (glIndex %ld, d3dIndex %ld, enabled %d)\n", el, el->glIndex, el->OriginalIndex, el->lightEnabled);\
314 el = el->next; \
315 } \
316 }
317
318 /* Trace vector and strided data information */
319 #define TRACE_VECTOR(name) TRACE( #name "=(%f, %f, %f, %f)\n", name.x, name.y, name.z, name.w);
320 #define TRACE_STRIDED(sd,name) TRACE( #name "=(data:%p, stride:%d, type:%d, vbo %d, stream %u)\n", \
321 sd->u.s.name.lpData, sd->u.s.name.dwStride, sd->u.s.name.dwType, sd->u.s.name.VBO, sd->u.s.name.streamNo);
322
323 /* Defines used for optimizations */
324
325 /* Only reapply what is necessary */
326 #define REAPPLY_ALPHAOP 0x0001
327 #define REAPPLY_ALL 0xFFFF
328
329 /* Advance declaration of structures to satisfy compiler */
330 typedef struct IWineD3DStateBlockImpl IWineD3DStateBlockImpl;
331 typedef struct IWineD3DSurfaceImpl IWineD3DSurfaceImpl;
332 typedef struct IWineD3DPaletteImpl IWineD3DPaletteImpl;
333 typedef struct IWineD3DDeviceImpl IWineD3DDeviceImpl;
334
335 /* Global variables */
336 extern const float identity[16];
337
338 /*****************************************************************************
339 * Compilable extra diagnostics
340 */
341
342 /* Trace information per-vertex: (extremely high amount of trace) */
343 #if 0 /* NOTE: Must be 0 in cvs */
344 # define VTRACE(A) TRACE A
345 #else
346 # define VTRACE(A)
347 #endif
348
349 /* Checking of per-vertex related GL calls */
350 /* --------------------- */
351 #define vcheckGLcall(A) \
352 { \
353 GLint err = glGetError(); \
354 if (err == GL_NO_ERROR) { \
355 VTRACE(("%s call ok %s / %d\n", A, __FILE__, __LINE__)); \
356 \
357 } else do { \
358 FIXME(">>>>>>>>>>>>>>>>> %s (%#x) from %s @ %s / %d\n", \
359 debug_glerror(err), err, A, __FILE__, __LINE__); \
360 err = glGetError(); \
361 } while (err != GL_NO_ERROR); \
362 }
363
364 /* TODO: Confirm each of these works when wined3d move completed */
365 #if 0 /* NOTE: Must be 0 in cvs */
366 /* To avoid having to get gigabytes of trace, the following can be compiled in, and at the start
367 of each frame, a check is made for the existence of C:\D3DTRACE, and if it exists d3d trace
368 is enabled, and if it doesn't exist it is disabled. */
369 # define FRAME_DEBUGGING
370 /* Adding in the SINGLE_FRAME_DEBUGGING gives a trace of just what makes up a single frame, before
371 the file is deleted */
372 # if 1 /* NOTE: Must be 1 in cvs, as this is mostly more useful than a trace from program start */
373 # define SINGLE_FRAME_DEBUGGING
374 # endif
375 /* The following, when enabled, lets you see the makeup of the frame, by drawprimitive calls.
376 It can only be enabled when FRAME_DEBUGGING is also enabled
377 The contents of the back buffer are written into /tmp/backbuffer_* after each primitive
378 array is drawn. */
379 # if 0 /* NOTE: Must be 0 in cvs, as this give a lot of ppm files when compiled in */
380 # define SHOW_FRAME_MAKEUP 1
381 # endif
382 /* The following, when enabled, lets you see the makeup of the all the textures used during each
383 of the drawprimitive calls. It can only be enabled when SHOW_FRAME_MAKEUP is also enabled.
384 The contents of the textures assigned to each stage are written into
385 /tmp/texture_*_<Stage>.ppm after each primitive array is drawn. */
386 # if 0 /* NOTE: Must be 0 in cvs, as this give a lot of ppm files when compiled in */
387 # define SHOW_TEXTURE_MAKEUP 0
388 # endif
389 extern BOOL isOn;
390 extern BOOL isDumpingFrames;
391 extern LONG primCounter;
392 #endif
393
394 /*****************************************************************************
395 * Prototypes
396 */
397
398 /* Routine common to the draw primitive and draw indexed primitive routines */
399 void drawPrimitive(IWineD3DDevice *iface,
400 int PrimitiveType,
401 long NumPrimitives,
402 /* for Indexed: */
403 long StartVertexIndex,
404 UINT numberOfVertices,
405 long StartIdx,
406 short idxBytes,
407 const void *idxData,
408 int minIndex);
409
410 void primitiveDeclarationConvertToStridedData(
411 IWineD3DDevice *iface,
412 BOOL useVertexShaderFunction,
413 WineDirect3DVertexStridedData *strided,
414 BOOL *fixup);
415
416 DWORD get_flexible_vertex_size(DWORD d3dvtVertexType);
417
418 #define eps 1e-8
419
420 #define GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, tex_num) \
421 (((((d3dvtVertexType) >> (16 + (2 * (tex_num)))) + 1) & 0x03) + 1)
422
423 /* Routines and structures related to state management */
424 typedef struct WineD3DContext WineD3DContext;
425 typedef void (*APPLYSTATEFUNC)(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *ctx);
426
427 #define STATE_RENDER(a) (a)
428 #define STATE_IS_RENDER(a) ((a) >= STATE_RENDER(1) && (a) <= STATE_RENDER(WINEHIGHEST_RENDER_STATE))
429
430 #define STATE_TEXTURESTAGE(stage, num) (STATE_RENDER(WINEHIGHEST_RENDER_STATE) + (stage) * WINED3D_HIGHEST_TEXTURE_STATE + (num))
431 #define STATE_IS_TEXTURESTAGE(a) ((a) >= STATE_TEXTURESTAGE(0, 1) && (a) <= STATE_TEXTURESTAGE(MAX_TEXTURES - 1, WINED3D_HIGHEST_TEXTURE_STATE))
432
433 /* + 1 because samplers start with 0 */
434 #define STATE_SAMPLER(num) (STATE_TEXTURESTAGE(MAX_TEXTURES - 1, WINED3D_HIGHEST_TEXTURE_STATE) + 1 + (num))
435 #define STATE_IS_SAMPLER(num) ((num) >= STATE_SAMPLER(0) && (num) <= STATE_SAMPLER(MAX_COMBINED_SAMPLERS - 1))
436
437 #define STATE_PIXELSHADER (STATE_SAMPLER(MAX_COMBINED_SAMPLERS - 1) + 1)
438 #define STATE_IS_PIXELSHADER(a) ((a) == STATE_PIXELSHADER)
439
440 #define STATE_TRANSFORM(a) (STATE_PIXELSHADER + (a))
441 #define STATE_IS_TRANSFORM(a) ((a) >= STATE_TRANSFORM(1) && (a) <= STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)))
442
443 #define STATE_STREAMSRC (STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)) + 1)
444 #define STATE_IS_STREAMSRC(a) ((a) == STATE_STREAMSRC)
445 #define STATE_INDEXBUFFER (STATE_STREAMSRC + 1)
446 #define STATE_IS_INDEXBUFFER(a) ((a) == STATE_INDEXBUFFER)
447
448 #define STATE_VDECL (STATE_INDEXBUFFER + 1)
449 #define STATE_IS_VDECL(a) ((a) == STATE_VDECL)
450
451 #define STATE_VSHADER (STATE_VDECL + 1)
452 #define STATE_IS_VSHADER(a) ((a) == STATE_VSHADER)
453
454 #define STATE_VIEWPORT (STATE_VSHADER + 1)
455 #define STATE_IS_VIEWPORT(a) ((a) == STATE_VIEWPORT)
456
457 #define STATE_VERTEXSHADERCONSTANT (STATE_VIEWPORT + 1)
458 #define STATE_PIXELSHADERCONSTANT (STATE_VERTEXSHADERCONSTANT + 1)
459 #define STATE_IS_VERTEXSHADERCONSTANT(a) ((a) == STATE_VERTEXSHADERCONSTANT)
460 #define STATE_IS_PIXELSHADERCONSTANT(a) ((a) == STATE_PIXELSHADERCONSTANT)
461
462 #define STATE_ACTIVELIGHT(a) (STATE_PIXELSHADERCONSTANT + (a) + 1)
463 #define STATE_IS_ACTIVELIGHT(a) ((a) >= STATE_ACTIVELIGHT(0) && (a) < STATE_ACTIVELIGHT(MAX_ACTIVE_LIGHTS))
464
465 #define STATE_SCISSORRECT (STATE_ACTIVELIGHT(MAX_ACTIVE_LIGHTS - 1) + 1)
466 #define STATE_IS_SCISSORRECT(a) ((a) == STATE_SCISSORRECT)
467
468 #define STATE_CLIPPLANE(a) (STATE_SCISSORRECT + 1 + (a))
469 #define STATE_IS_CLIPPLANE(a) ((a) >= STATE_CLIPPLANE(0) && (a) <= STATE_CLIPPLANE(MAX_CLIPPLANES - 1))
470
471 #define STATE_MATERIAL (STATE_CLIPPLANE(MAX_CLIPPLANES))
472
473 #define STATE_FRONTFACE (STATE_MATERIAL + 1)
474
475 #define STATE_HIGHEST (STATE_FRONTFACE)
476
477 struct StateEntry
478 {
479 DWORD representative;
480 APPLYSTATEFUNC apply;
481 };
482
483 /* Global state table */
484 extern const struct StateEntry StateTable[];
485
486 /* The new context manager that should deal with onscreen and offscreen rendering */
487 struct WineD3DContext {
488 /* State dirtification
489 * dirtyArray is an array that contains markers for dirty states. numDirtyEntries states are dirty, their numbers are in indices
490 * 0...numDirtyEntries - 1. isStateDirty is a redundant copy of the dirtyArray. Technically only one of them would be needed,
491 * 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
492 * only numDirtyEntries array elements have to be checked, not STATE_HIGHEST states.
493 */
494 DWORD dirtyArray[STATE_HIGHEST + 1]; /* Won't get bigger than that, a state is never marked dirty 2 times */
495 DWORD numDirtyEntries;
496 DWORD isStateDirty[STATE_HIGHEST/32 + 1]; /* Bitmap to find out quickly if a state is dirty */
497
498 IWineD3DSurface *surface;
499 DWORD tid; /* Thread ID which owns this context at the moment */
500
501 /* Stores some inforation about the context state for optimization */
502 GLint last_draw_buffer;
503 BOOL last_was_rhw; /* true iff last draw_primitive was in xyzrhw mode */
504 BOOL last_was_pshader;
505 BOOL last_was_vshader;
506 BOOL last_was_foggy_shader;
507 BOOL namedArraysLoaded, numberedArraysLoaded;
508 BOOL lastWasPow2Texture[MAX_TEXTURES];
509 GLenum tracking_parm; /* Which source is tracking current colour */
510 unsigned char num_untracked_materials;
511 GLenum untracked_materials[2];
512 BOOL last_was_blit, last_was_ckey;
513 char texShaderBumpMap;
514 BOOL fog_coord;
515
516 /* The actual opengl context */
517 HGLRC glCtx;
518 HWND win_handle;
519 HDC hdc;
520 HPBUFFERARB pbuffer;
521 BOOL isPBuffer;
522 };
523
524 typedef enum ContextUsage {
525 CTXUSAGE_RESOURCELOAD = 1, /* Only loads textures: No State is applied */
526 CTXUSAGE_DRAWPRIM = 2, /* OpenGL states are set up for blitting DirectDraw surfacs */
527 CTXUSAGE_BLIT = 3, /* OpenGL states are set up 3D drawing */
528 CTXUSAGE_CLEAR = 4, /* Drawable and states are set up for clearing */
529 } ContextUsage;
530
531 void ActivateContext(IWineD3DDeviceImpl *device, IWineD3DSurface *target, ContextUsage usage);
532 WineD3DContext *CreateContext(IWineD3DDeviceImpl *This, IWineD3DSurfaceImpl *target, HWND win, BOOL create_pbuffer, const WINED3DPRESENT_PARAMETERS *pPresentParms);
533 void DestroyContext(IWineD3DDeviceImpl *This, WineD3DContext *context);
534 void apply_fbo_state(IWineD3DDevice *iface);
535
536 /* Macros for doing basic GPU detection based on opengl capabilities */
537 #define WINE_D3D6_CAPABLE(gl_info) (gl_info->supported[ARB_MULTITEXTURE])
538 #define WINE_D3D7_CAPABLE(gl_info) (gl_info->supported[ARB_TEXTURE_COMPRESSION] && gl_info->supported[ARB_TEXTURE_CUBE_MAP] && gl_info->supported[ARB_TEXTURE_ENV_DOT3])
539 #define WINE_D3D8_CAPABLE(gl_info) WINE_D3D7_CAPABLE(gl_info) && (gl_info->supported[ARB_MULTISAMPLE] && gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
540 #define WINE_D3D9_CAPABLE(gl_info) WINE_D3D8_CAPABLE(gl_info) && (gl_info->supported[ARB_FRAGMENT_PROGRAM] && gl_info->supported[ARB_VERTEX_SHADER])
541
542 /* Default callbacks for implicit object destruction */
543 extern ULONG WINAPI D3DCB_DefaultDestroySurface(IWineD3DSurface *pSurface);
544
545 extern ULONG WINAPI D3DCB_DefaultDestroyVolume(IWineD3DVolume *pSurface);
546
547 /*****************************************************************************
548 * Internal representation of a light
549 */
550 typedef struct PLIGHTINFOEL PLIGHTINFOEL;
551 struct PLIGHTINFOEL {
552 WINED3DLIGHT OriginalParms; /* Note D3D8LIGHT == D3D9LIGHT */
553 DWORD OriginalIndex;
554 LONG glIndex;
555 BOOL changed;
556 BOOL enabledChanged;
557
558 /* Converted parms to speed up swapping lights */
559 float lightPosn[4];
560 float lightDirn[4];
561 float exponent;
562 float cutoff;
563
564 struct list entry;
565 };
566
567 /* The default light parameters */
568 extern const WINED3DLIGHT WINED3D_default_light;
569
570 typedef struct WineD3D_PixelFormat
571 {
572 int iPixelFormat; /* WGL pixel format */
573 int redSize, greenSize, blueSize, alphaSize;
574 int depthSize, stencilSize;
575 } WineD3D_PixelFormat;
576
577 /* The adapter structure */
578 typedef struct GLPixelFormatDesc GLPixelFormatDesc;
579 struct WineD3DAdapter
580 {
581 POINT monitorPoint;
582 WineD3D_GL_Info gl_info;
583 const char *driver;
584 const char *description;
585 WCHAR DeviceName[CCHDEVICENAME]; /* DeviceName for use with e.g. ChangeDisplaySettings */
586 int nCfgs;
587 WineD3D_PixelFormat *cfgs;
588 unsigned int TextureRam; /* Amount of texture memory both video ram + AGP/TurboCache/HyperMemory/.. */
589 unsigned int UsedTextureRam;
590 };
591
592 extern BOOL InitAdapters(void);
593 extern BOOL initPixelFormats(WineD3D_GL_Info *gl_info);
594 extern long WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl *D3DDevice, long glram);
595
596 /*****************************************************************************
597 * High order patch management
598 */
599 struct WineD3DRectPatch
600 {
601 UINT Handle;
602 float *mem;
603 WineDirect3DVertexStridedData strided;
604 WINED3DRECTPATCH_INFO RectPatchInfo;
605 float numSegs[4];
606 char has_normals, has_texcoords;
607 struct list entry;
608 };
609
610 HRESULT tesselate_rectpatch(IWineD3DDeviceImpl *This, struct WineD3DRectPatch *patch);
611
612 /*****************************************************************************
613 * IWineD3D implementation structure
614 */
615 typedef struct IWineD3DImpl
616 {
617 /* IUnknown fields */
618 const IWineD3DVtbl *lpVtbl;
619 LONG ref; /* Note: Ref counting not required */
620
621 /* WineD3D Information */
622 IUnknown *parent;
623 UINT dxVersion;
624 } IWineD3DImpl;
625
626 extern const IWineD3DVtbl IWineD3D_Vtbl;
627
628 /* TODO: setup some flags in the registry to enable, disable pbuffer support
629 (since it will break quite a few things until contexts are managed properly!) */
630 extern BOOL pbuffer_support;
631 /* allocate one pbuffer per surface */
632 extern BOOL pbuffer_per_surface;
633
634 typedef struct ResourceList {
635 IWineD3DResource *resource;
636 struct ResourceList *next;
637 } ResourceList;
638
639 /* A helper function that dumps a resource list */
640 void dumpResources(ResourceList *resources);
641
642 /*****************************************************************************
643 * IWineD3DDevice implementation structure
644 */
645 struct IWineD3DDeviceImpl
646 {
647 /* IUnknown fields */
648 const IWineD3DDeviceVtbl *lpVtbl;
649 LONG ref; /* Note: Ref counting not required */
650
651 /* WineD3D Information */
652 IUnknown *parent;
653 IWineD3D *wineD3D;
654 struct WineD3DAdapter *adapter;
655
656 /* Window styles to restore when switching fullscreen mode */
657 LONG style;
658 LONG exStyle;
659
660 /* X and GL Information */
661 GLint maxConcurrentLights;
662 GLenum offscreenBuffer;
663
664 /* Selected capabilities */
665 int vs_selected_mode;
666 int ps_selected_mode;
667 const shader_backend_t *shader_backend;
668 hash_table_t *glsl_program_lookup;
669
670 /* To store */
671 BOOL view_ident; /* true iff view matrix is identity */
672 BOOL untransformed;
673 BOOL vertexBlendUsed; /* To avoid needless setting of the blend matrices */
674 unsigned char surface_alignment; /* Line Alignment of surfaces */
675
676 /* State block related */
677 BOOL isRecordingState;
678 IWineD3DStateBlockImpl *stateBlock;
679 IWineD3DStateBlockImpl *updateStateBlock;
680 BOOL isInDraw;
681
682 /* Internal use fields */
683 WINED3DDEVICE_CREATION_PARAMETERS createParms;
684 UINT adapterNo;
685 WINED3DDEVTYPE devType;
686
687 IWineD3DSwapChain **swapchains;
688 UINT NumberOfSwapChains;
689
690 ResourceList *resources; /* a linked list to track resources created by the device */
691
692 /* Render Target Support */
693 IWineD3DSurface **render_targets;
694 IWineD3DSurface *depthStencilBuffer;
695 IWineD3DSurface **fbo_color_attachments;
696 IWineD3DSurface *fbo_depth_attachment;
697
698 IWineD3DSurface *stencilBufferTarget;
699
700 /* Caches to avoid unneeded context changes */
701 IWineD3DSurface *lastActiveRenderTarget;
702 IWineD3DSwapChain *lastActiveSwapChain;
703
704 /* palettes texture management */
705 PALETTEENTRY palettes[MAX_PALETTES][256];
706 UINT currentPalette;
707 UINT paletteConversionShader;
708
709 /* For rendering to a texture using glCopyTexImage */
710 BOOL render_offscreen;
711 WINED3D_DEPTHCOPYSTATE depth_copy_state;
712 GLuint fbo;
713 GLuint src_fbo;
714 GLuint dst_fbo;
715 GLenum *draw_buffers;
716
717 /* Cursor management */
718 BOOL bCursorVisible;
719 UINT xHotSpot;
720 UINT yHotSpot;
721 UINT xScreenSpace;
722 UINT yScreenSpace;
723 UINT cursorWidth, cursorHeight;
724 GLuint cursorTexture;
725 BOOL haveHardwareCursor;
726 HCURSOR hardwareCursor;
727
728 /* The Wine logo surface */
729 IWineD3DSurface *logo_surface;
730
731 /* Textures for when no other textures are mapped */
732 UINT dummyTextureName[MAX_TEXTURES];
733
734 /* Debug stream management */
735 BOOL debug;
736
737 /* Device state management */
738 HRESULT state;
739 BOOL d3d_initialized;
740
741 /* A flag to check for proper BeginScene / EndScene call pairs */
742 BOOL inScene;
743
744 /* process vertex shaders using software or hardware */
745 BOOL softwareVertexProcessing;
746
747 /* DirectDraw stuff */
748 HWND ddraw_window;
749 IWineD3DSurface *ddraw_primary;
750 DWORD ddraw_width, ddraw_height;
751 WINED3DFORMAT ddraw_format;
752 BOOL ddraw_fullscreen;
753
754 /* Final position fixup constant */
755 float posFixup[4];
756
757 /* With register combiners we can skip junk texture stages */
758 DWORD texUnitMap[MAX_COMBINED_SAMPLERS];
759 DWORD rev_tex_unit_map[MAX_COMBINED_SAMPLERS];
760 BOOL fixed_function_usage_map[MAX_TEXTURES];
761
762 /* Stream source management */
763 WineDirect3DVertexStridedData strided_streams;
764 WineDirect3DVertexStridedData *up_strided;
765 BOOL useDrawStridedSlow;
766 BOOL instancedDraw;
767
768 /* Context management */
769 WineD3DContext **contexts; /* Dynamic array containing pointers to context structures */
770 WineD3DContext *activeContext;
771 DWORD lastThread;
772 UINT numContexts;
773 WineD3DContext *pbufferContext; /* The context that has a pbuffer as drawable */
774 DWORD pbufferWidth, pbufferHeight; /* Size of the buffer drawable */
775
776 /* High level patch management */
777 #define PATCHMAP_SIZE 43
778 #define PATCHMAP_HASHFUNC(x) ((x) % PATCHMAP_SIZE) /* Primitive and simple function */
779 struct list patches[PATCHMAP_SIZE];
780 struct WineD3DRectPatch *currentPatch;
781 };
782
783 extern const IWineD3DDeviceVtbl IWineD3DDevice_Vtbl;
784
785 void IWineD3DDeviceImpl_FindTexUnitMap(IWineD3DDeviceImpl *This);
786 void IWineD3DDeviceImpl_MarkStateDirty(IWineD3DDeviceImpl *This, DWORD state);
787 static inline BOOL isStateDirty(WineD3DContext *context, DWORD state) {
788 DWORD idx = state >> 5;
789 BYTE shift = state & 0x1f;
790 return context->isStateDirty[idx] & (1 << shift);
791 }
792
793 /* Support for IWineD3DResource ::Set/Get/FreePrivateData. */
794 typedef struct PrivateData
795 {
796 struct list entry;
797
798 GUID tag;
799 DWORD flags; /* DDSPD_* */
800 DWORD uniqueness_value;
801
802 union
803 {
804 LPVOID data;
805 LPUNKNOWN object;
806 } ptr;
807
808 DWORD size;
809 } PrivateData;
810
811 /*****************************************************************************
812 * IWineD3DResource implementation structure
813 */
814 typedef struct IWineD3DResourceClass
815 {
816 /* IUnknown fields */
817 LONG ref; /* Note: Ref counting not required */
818
819 /* WineD3DResource Information */
820 IUnknown *parent;
821 WINED3DRESOURCETYPE resourceType;
822 IWineD3DDeviceImpl *wineD3DDevice;
823 WINED3DPOOL pool;
824 UINT size;
825 DWORD usage;
826 WINED3DFORMAT format;
827 BYTE *allocatedMemory; /* Pointer to the real data location */
828 BYTE *heapMemory; /* Pointer to the HeapAlloced block of memory */
829 struct list privateData;
830
831 } IWineD3DResourceClass;
832
833 typedef struct IWineD3DResourceImpl
834 {
835 /* IUnknown & WineD3DResource Information */
836 const IWineD3DResourceVtbl *lpVtbl;
837 IWineD3DResourceClass resource;
838 } IWineD3DResourceImpl;
839
840 /* Tests show that the start address of resources is 32 byte aligned */
841 #define RESOURCE_ALIGNMENT 32
842
843 /*****************************************************************************
844 * IWineD3DVertexBuffer implementation structure (extends IWineD3DResourceImpl)
845 */
846 typedef struct IWineD3DVertexBufferImpl
847 {
848 /* IUnknown & WineD3DResource Information */
849 const IWineD3DVertexBufferVtbl *lpVtbl;
850 IWineD3DResourceClass resource;
851
852 /* WineD3DVertexBuffer specifics */
853 DWORD fvf;
854
855 /* Vertex buffer object support */
856 GLuint vbo;
857 BYTE Flags;
858 LONG bindCount;
859
860 UINT dirtystart, dirtyend;
861 LONG lockcount;
862
863 LONG declChanges, draws;
864 /* Last description of the buffer */
865 WineDirect3DVertexStridedData strided;
866 } IWineD3DVertexBufferImpl;
867
868 extern const IWineD3DVertexBufferVtbl IWineD3DVertexBuffer_Vtbl;
869
870 #define VBFLAG_LOAD 0x01 /* Data is written from allocatedMemory to the VBO */
871 #define VBFLAG_OPTIMIZED 0x02 /* Optimize has been called for the VB */
872 #define VBFLAG_DIRTY 0x04 /* Buffer data has been modified */
873 #define VBFLAG_HASDESC 0x08 /* A vertex description has been found */
874 #define VBFLAG_VBOCREATEFAIL 0x10 /* An attempt to create a vbo has failed */
875
876 /*****************************************************************************
877 * IWineD3DIndexBuffer implementation structure (extends IWineD3DResourceImpl)
878 */
879 typedef struct IWineD3DIndexBufferImpl
880 {
881 /* IUnknown & WineD3DResource Information */
882 const IWineD3DIndexBufferVtbl *lpVtbl;
883 IWineD3DResourceClass resource;
884
885 GLuint vbo;
886 UINT dirtystart, dirtyend;
887 LONG lockcount;
888
889 /* WineD3DVertexBuffer specifics */
890 } IWineD3DIndexBufferImpl;
891
892 extern const IWineD3DIndexBufferVtbl IWineD3DIndexBuffer_Vtbl;
893
894 /*****************************************************************************
895 * IWineD3DBaseTexture D3D- > openGL state map lookups
896 */
897 #define WINED3DFUNC_NOTSUPPORTED -2
898 #define WINED3DFUNC_UNIMPLEMENTED -1
899
900 typedef enum winetexturestates {
901 WINED3DTEXSTA_ADDRESSU = 0,
902 WINED3DTEXSTA_ADDRESSV = 1,
903 WINED3DTEXSTA_ADDRESSW = 2,
904 WINED3DTEXSTA_BORDERCOLOR = 3,
905 WINED3DTEXSTA_MAGFILTER = 4,
906 WINED3DTEXSTA_MINFILTER = 5,
907 WINED3DTEXSTA_MIPFILTER = 6,
908 WINED3DTEXSTA_MAXMIPLEVEL = 7,
909 WINED3DTEXSTA_MAXANISOTROPY = 8,
910 WINED3DTEXSTA_SRGBTEXTURE = 9,
911 WINED3DTEXSTA_ELEMENTINDEX = 10,
912 WINED3DTEXSTA_DMAPOFFSET = 11,
913 WINED3DTEXSTA_TSSADDRESSW = 12,
914 MAX_WINETEXTURESTATES = 13,
915 } winetexturestates;
916
917 /*****************************************************************************
918 * IWineD3DBaseTexture implementation structure (extends IWineD3DResourceImpl)
919 */
920 typedef struct IWineD3DBaseTextureClass
921 {
922 UINT levels;
923 BOOL dirty;
924 UINT textureName;
925 UINT LOD;
926 WINED3DTEXTUREFILTERTYPE filterType;
927 DWORD states[MAX_WINETEXTURESTATES];
928 LONG bindCount;
929 DWORD sampler;
930 BOOL is_srgb;
931 UINT srgb_mode_change_count;
932 WINED3DFORMAT shader_conversion_group;
933 } IWineD3DBaseTextureClass;
934
935 typedef struct IWineD3DBaseTextureImpl
936 {
937 /* IUnknown & WineD3DResource Information */
938 const IWineD3DBaseTextureVtbl *lpVtbl;
939 IWineD3DResourceClass resource;
940 IWineD3DBaseTextureClass baseTexture;
941
942 } IWineD3DBaseTextureImpl;
943
944 /*****************************************************************************
945 * IWineD3DTexture implementation structure (extends IWineD3DBaseTextureImpl)
946 */
947 typedef struct IWineD3DTextureImpl
948 {
949 /* IUnknown & WineD3DResource/WineD3DBaseTexture Information */
950 const IWineD3DTextureVtbl *lpVtbl;
951 IWineD3DResourceClass resource;
952 IWineD3DBaseTextureClass baseTexture;
953
954 /* IWineD3DTexture */
955 IWineD3DSurface *surfaces[MAX_LEVELS];
956
957 UINT width;
958 UINT height;
959 float pow2scalingFactorX;
960 float pow2scalingFactorY;
961
962 } IWineD3DTextureImpl;
963
964 extern const IWineD3DTextureVtbl IWineD3DTexture_Vtbl;
965
966 /*****************************************************************************
967 * IWineD3DCubeTexture implementation structure (extends IWineD3DBaseTextureImpl)
968 */
969 typedef struct IWineD3DCubeTextureImpl
970 {
971 /* IUnknown & WineD3DResource/WineD3DBaseTexture Information */
972 const IWineD3DCubeTextureVtbl *lpVtbl;
973 IWineD3DResourceClass resource;
974 IWineD3DBaseTextureClass baseTexture;
975
976 /* IWineD3DCubeTexture */
977 IWineD3DSurface *surfaces[6][MAX_LEVELS];
978
979 UINT edgeLength;
980 float pow2scalingFactor;
981
982 } IWineD3DCubeTextureImpl;
983
984 extern const IWineD3DCubeTextureVtbl IWineD3DCubeTexture_Vtbl;
985
986 typedef struct _WINED3DVOLUMET_DESC
987 {
988 UINT Width;
989 UINT Height;
990 UINT Depth;
991 } WINED3DVOLUMET_DESC;
992
993 /*****************************************************************************
994 * IWineD3DVolume implementation structure (extends IUnknown)
995 */
996 typedef struct IWineD3DVolumeImpl
997 {
998 /* IUnknown & WineD3DResource fields */
999 const IWineD3DVolumeVtbl *lpVtbl;
1000 IWineD3DResourceClass resource;
1001
1002 /* WineD3DVolume Information */
1003 WINED3DVOLUMET_DESC currentDesc;
1004 IWineD3DBase *container;
1005 UINT bytesPerPixel;
1006
1007 BOOL lockable;
1008 BOOL locked;
1009 WINED3DBOX lockedBox;
1010 WINED3DBOX dirtyBox;
1011 BOOL dirty;
1012
1013
1014 } IWineD3DVolumeImpl;
1015
1016 extern const IWineD3DVolumeVtbl IWineD3DVolume_Vtbl;
1017
1018 /*****************************************************************************
1019 * IWineD3DVolumeTexture implementation structure (extends IWineD3DBaseTextureImpl)
1020 */
1021 typedef struct IWineD3DVolumeTextureImpl
1022 {
1023 /* IUnknown & WineD3DResource/WineD3DBaseTexture Information */
1024 const IWineD3DVolumeTextureVtbl *lpVtbl;
1025 IWineD3DResourceClass resource;
1026 IWineD3DBaseTextureClass baseTexture;
1027
1028 /* IWineD3DVolumeTexture */
1029 IWineD3DVolume *volumes[MAX_LEVELS];
1030
1031 UINT width;
1032 UINT height;
1033 UINT depth;
1034 } IWineD3DVolumeTextureImpl;
1035
1036 extern const IWineD3DVolumeTextureVtbl IWineD3DVolumeTexture_Vtbl;
1037
1038 typedef struct _WINED3DSURFACET_DESC
1039 {
1040 WINED3DMULTISAMPLE_TYPE MultiSampleType;
1041 DWORD MultiSampleQuality;
1042 UINT Width;
1043 UINT Height;
1044 } WINED3DSURFACET_DESC;
1045
1046 /*****************************************************************************
1047 * Structure for DIB Surfaces (GetDC and GDI surfaces)
1048 */
1049 typedef struct wineD3DSurface_DIB {
1050 HBITMAP DIBsection;
1051 void* bitmap_data;
1052 UINT bitmap_size;
1053 HGDIOBJ holdbitmap;
1054 BOOL client_memory;
1055 } wineD3DSurface_DIB;
1056
1057 typedef struct {
1058 struct list entry;
1059 GLuint id;
1060 UINT width;
1061 UINT height;
1062 } renderbuffer_entry_t;
1063
1064 /*****************************************************************************
1065 * IWineD3DClipp implementation structure
1066 */
1067 typedef struct IWineD3DClipperImpl
1068 {
1069 const IWineD3DClipperVtbl *lpVtbl;
1070 LONG ref;
1071
1072 IUnknown *Parent;
1073 HWND hWnd;
1074 } IWineD3DClipperImpl;
1075
1076
1077 /*****************************************************************************
1078 * IWineD3DSurface implementation structure
1079 */
1080 struct IWineD3DSurfaceImpl
1081 {
1082 /* IUnknown & IWineD3DResource Information */
1083 const IWineD3DSurfaceVtbl *lpVtbl;
1084 IWineD3DResourceClass resource;
1085
1086 /* IWineD3DSurface fields */
1087 IWineD3DBase *container;
1088 WINED3DSURFACET_DESC currentDesc;
1089 IWineD3DPaletteImpl *palette; /* D3D7 style palette handling */
1090 PALETTEENTRY *palette9; /* D3D8/9 style palette handling */
1091
1092 UINT bytesPerPixel;
1093
1094 /* TODO: move this off into a management class(maybe!) */
1095 DWORD Flags;
1096
1097 UINT pow2Width;
1098 UINT pow2Height;
1099
1100 /* Oversized texture */
1101 RECT glRect;
1102
1103 /* PBO */
1104 GLuint pbo;
1105
1106 #if 0
1107 /* precalculated x and y scalings for texture coords */
1108 float pow2scalingFactorX; /* = (Width / pow2Width ) */
1109 float pow2scalingFactorY; /* = (Height / pow2Height) */
1110 #endif
1111
1112 RECT lockedRect;
1113 RECT dirtyRect;
1114 int lockCount;
1115 #define MAXLOCKCOUNT 50 /* After this amount of locks do not free the sysmem copy */
1116
1117 glDescriptor glDescription;
1118 BOOL srgb;
1119
1120 /* For GetDC */
1121 wineD3DSurface_DIB dib;
1122 HDC hDC;
1123
1124 /* Color keys for DDraw */
1125 WINEDDCOLORKEY DestBltCKey;
1126 WINEDDCOLORKEY DestOverlayCKey;
1127 WINEDDCOLORKEY SrcOverlayCKey;
1128 WINEDDCOLORKEY SrcBltCKey;
1129 DWORD CKeyFlags;
1130
1131 WINEDDCOLORKEY glCKey;
1132
1133 struct list renderbuffers;
1134 renderbuffer_entry_t *current_renderbuffer;
1135
1136 /* DirectDraw clippers */
1137 IWineD3DClipper *clipper;
1138 };
1139
1140 extern const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl;
1141 extern const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl;
1142
1143 /* Predeclare the shared Surface functions */
1144 HRESULT WINAPI IWineD3DBaseSurfaceImpl_QueryInterface(IWineD3DSurface *iface, REFIID riid, LPVOID *ppobj);
1145 ULONG WINAPI IWineD3DBaseSurfaceImpl_AddRef(IWineD3DSurface *iface);
1146 HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetParent(IWineD3DSurface *iface, IUnknown **pParent);
1147 HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetDevice(IWineD3DSurface *iface, IWineD3DDevice** ppDevice);
1148 HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetPrivateData(IWineD3DSurface *iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags);
1149 HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetPrivateData(IWineD3DSurface *iface, REFGUID refguid, void* pData, DWORD* pSizeOfData);
1150 HRESULT WINAPI IWineD3DBaseSurfaceImpl_FreePrivateData(IWineD3DSurface *iface, REFGUID refguid);
1151 DWORD WINAPI IWineD3DBaseSurfaceImpl_SetPriority(IWineD3DSurface *iface, DWORD PriorityNew);
1152 DWORD WINAPI IWineD3DBaseSurfaceImpl_GetPriority(IWineD3DSurface *iface);
1153 WINED3DRESOURCETYPE WINAPI IWineD3DBaseSurfaceImpl_GetType(IWineD3DSurface *iface);
1154 HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetContainer(IWineD3DSurface* iface, REFIID riid, void** ppContainer);
1155 HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetDesc(IWineD3DSurface *iface, WINED3DSURFACE_DESC *pDesc);
1156 HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetBltStatus(IWineD3DSurface *iface, DWORD Flags);
1157 HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetFlipStatus(IWineD3DSurface *iface, DWORD Flags);
1158 HRESULT WINAPI IWineD3DBaseSurfaceImpl_IsLost(IWineD3DSurface *iface);
1159 HRESULT WINAPI IWineD3DBaseSurfaceImpl_Restore(IWineD3DSurface *iface);
1160 HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetPalette(IWineD3DSurface *iface, IWineD3DPalette **Pal);
1161 HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetPalette(IWineD3DSurface *iface, IWineD3DPalette *Pal);
1162 HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetColorKey(IWineD3DSurface *iface, DWORD Flags, WINEDDCOLORKEY *CKey);
1163 HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetContainer(IWineD3DSurface *iface, IWineD3DBase *container);
1164 DWORD WINAPI IWineD3DBaseSurfaceImpl_GetPitch(IWineD3DSurface *iface);
1165 HRESULT WINAPI IWineD3DBaseSurfaceImpl_RealizePalette(IWineD3DSurface *iface);
1166 HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetOverlayPosition(IWineD3DSurface *iface, LONG X, LONG Y);
1167 HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetOverlayPosition(IWineD3DSurface *iface, LONG *X, LONG *Y);
1168 HRESULT WINAPI IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder(IWineD3DSurface *iface, DWORD Flags, IWineD3DSurface *Ref);
1169 HRESULT WINAPI IWineD3DBaseSurfaceImpl_UpdateOverlay(IWineD3DSurface *iface, RECT *SrcRect, IWineD3DSurface *DstSurface, RECT *DstRect, DWORD Flags, WINEDDOVERLAYFX *FX);
1170 HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetClipper(IWineD3DSurface *iface, IWineD3DClipper *clipper);
1171 HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetClipper(IWineD3DSurface *iface, IWineD3DClipper **clipper);
1172 HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetFormat(IWineD3DSurface *iface, WINED3DFORMAT format);
1173 HRESULT IWineD3DBaseSurfaceImpl_CreateDIBSection(IWineD3DSurface *iface);
1174 HRESULT WINAPI IWineD3DBaseSurfaceImpl_Blt(IWineD3DSurface *iface, RECT *DestRect, IWineD3DSurface *SrcSurface, RECT *SrcRect, DWORD Flags, WINEDDBLTFX *DDBltFx, WINED3DTEXTUREFILTERTYPE Filter);
1175 HRESULT WINAPI IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dstx, DWORD dsty, IWineD3DSurface *Source, RECT *rsrc, DWORD trans);
1176 HRESULT WINAPI IWineD3DBaseSurfaceImpl_LockRect(IWineD3DSurface *iface, WINED3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags);
1177
1178 const void *WINAPI IWineD3DSurfaceImpl_GetData(IWineD3DSurface *iface);
1179
1180 /* Surface flags: */
1181 #define SFLAG_OVERSIZE 0x00000001 /* Surface is bigger than gl size, blts only */
1182 #define SFLAG_CONVERTED 0x00000002 /* Converted for color keying or Palettized */
1183 #define SFLAG_DIBSECTION 0x00000004 /* Has a DIB section attached for getdc */
1184 #define SFLAG_LOCKABLE 0x00000008 /* Surface can be locked */
1185 #define SFLAG_DISCARD 0x00000010 /* ??? */
1186 #define SFLAG_LOCKED 0x00000020 /* Surface is locked atm */
1187 #define SFLAG_INTEXTURE 0x00000040 /* The GL texture contains the newest surface content */
1188 #define SFLAG_INDRAWABLE 0x00000080 /* The gl drawable contains the most up to date data */
1189 #define SFLAG_INSYSMEM 0x00000100 /* The system memory copy is most up to date */
1190 #define SFLAG_NONPOW2 0x00000200 /* Surface sizes are not a power of 2 */
1191 #define SFLAG_DYNLOCK 0x00000400 /* Surface is often locked by the app */
1192 #define SFLAG_DYNCHANGE 0x00000C00 /* Surface contents are changed very often, implies DYNLOCK */
1193 #define SFLAG_DCINUSE 0x00001000 /* Set between GetDC and ReleaseDC calls */
1194 #define SFLAG_LOST 0x00002000 /* Surface lost flag for DDraw */
1195 #define SFLAG_USERPTR 0x00004000 /* The application allocated the memory for this surface */
1196 #define SFLAG_GLCKEY 0x00008000 /* The gl texture was created with a color key */
1197 #define SFLAG_CLIENT 0x00010000 /* GL_APPLE_client_storage is used on that texture */
1198 #define SFLAG_ALLOCATED 0x00020000 /* A gl texture is allocated for this surface */
1199 #define SFLAG_PBO 0x00040000 /* Has a PBO attached for speeding up data transfers for dynamically locked surfaces */
1200
1201 /* In some conditions the surface memory must not be freed:
1202 * SFLAG_OVERSIZE: Not all data can be kept in GL
1203 * SFLAG_CONVERTED: Converting the data back would take too long
1204 * SFLAG_DIBSECTION: The dib code manages the memory
1205 * SFLAG_LOCKED: The app requires access to the surface data
1206 * SFLAG_DYNLOCK: Avoid freeing the data for performance
1207 * SFLAG_DYNCHANGE: Same reason as DYNLOCK
1208 * SFLAG_PBO: PBOs don't use 'normal' memory. It is either allocated by the driver or must be NULL.
1209 * SFLAG_CLIENT: OpenGL uses our memory as backup
1210 */
1211 #define SFLAG_DONOTFREE (SFLAG_OVERSIZE | \
1212 SFLAG_CONVERTED | \
1213 SFLAG_DIBSECTION | \
1214 SFLAG_LOCKED | \
1215 SFLAG_DYNLOCK | \
1216 SFLAG_DYNCHANGE | \
1217 SFLAG_USERPTR | \
1218 SFLAG_PBO | \
1219 SFLAG_CLIENT)
1220
1221 #define SFLAG_LOCATIONS (SFLAG_INSYSMEM | \
1222 SFLAG_INTEXTURE | \
1223 SFLAG_INDRAWABLE)
1224 BOOL CalculateTexRect(IWineD3DSurfaceImpl *This, RECT *Rect, float glTexCoord[4]);
1225
1226 typedef enum {
1227 NO_CONVERSION,
1228 CONVERT_PALETTED,
1229 CONVERT_PALETTED_CK,
1230 CONVERT_CK_565,
1231 CONVERT_CK_5551,
1232 CONVERT_CK_4444,
1233 CONVERT_CK_4444_ARGB,
1234 CONVERT_CK_1555,
1235 CONVERT_555,
1236 CONVERT_CK_RGB24,
1237 CONVERT_CK_8888,
1238 CONVERT_CK_8888_ARGB,
1239 CONVERT_RGB32_888,
1240 CONVERT_V8U8,
1241 CONVERT_L6V5U5,
1242 CONVERT_X8L8V8U8,
1243 CONVERT_Q8W8V8U8,
1244 CONVERT_V16U16,
1245 CONVERT_A4L4,
1246 CONVERT_R32F,
1247 CONVERT_R16F
1248 } CONVERT_TYPES;
1249
1250 HRESULT d3dfmt_get_conv(IWineD3DSurfaceImpl *This, BOOL need_alpha_ck, BOOL use_texturing, GLenum *format, GLenum *internal, GLenum *type, CONVERT_TYPES *convert, int *target_bpp, BOOL srgb_mode);
1251
1252 /*****************************************************************************
1253 * IWineD3DVertexDeclaration implementation structure
1254 */
1255 typedef struct IWineD3DVertexDeclarationImpl {
1256 /* IUnknown Information */
1257 const IWineD3DVertexDeclarationVtbl *lpVtbl;
1258 LONG ref;
1259
1260 IUnknown *parent;
1261 IWineD3DDeviceImpl *wineD3DDevice;
1262
1263 WINED3DVERTEXELEMENT *pDeclarationWine;
1264 UINT declarationWNumElements;
1265
1266 DWORD streams[MAX_STREAMS];
1267 UINT num_streams;
1268 BOOL position_transformed;
1269 } IWineD3DVertexDeclarationImpl;
1270
1271 extern const IWineD3DVertexDeclarationVtbl IWineD3DVertexDeclaration_Vtbl;
1272
1273 /*****************************************************************************
1274 * IWineD3DStateBlock implementation structure
1275 */
1276
1277 /* Internal state Block for Begin/End/Capture/Create/Apply info */
1278 /* Note: Very long winded but gl Lists are not flexible enough */
1279 /* to resolve everything we need, so doing it manually for now */
1280 typedef struct SAVEDSTATES {
1281 BOOL indices;
1282 BOOL material;
1283 BOOL fvf;
1284 BOOL streamSource[MAX_STREAMS];
1285 BOOL streamFreq[MAX_STREAMS];
1286 BOOL textures[MAX_COMBINED_SAMPLERS];
1287 BOOL transform[HIGHEST_TRANSFORMSTATE + 1];
1288 BOOL viewport;
1289 BOOL renderState[WINEHIGHEST_RENDER_STATE + 1];
1290 BOOL textureState[MAX_TEXTURES][WINED3D_HIGHEST_TEXTURE_STATE + 1];
1291 BOOL samplerState[MAX_COMBINED_SAMPLERS][WINED3D_HIGHEST_SAMPLER_STATE + 1];
1292 BOOL clipplane[MAX_CLIPPLANES];
1293 BOOL vertexDecl;
1294 BOOL pixelShader;
1295 BOOL pixelShaderConstantsB[MAX_CONST_B];
1296 BOOL pixelShaderConstantsI[MAX_CONST_I];
1297 BOOL *pixelShaderConstantsF;
1298 BOOL vertexShader;
1299 BOOL vertexShaderConstantsB[MAX_CONST_B];
1300 BOOL vertexShaderConstantsI[MAX_CONST_I];
1301 BOOL *vertexShaderConstantsF;
1302 BOOL scissorRect;
1303 } SAVEDSTATES;
1304
1305 typedef struct {
1306 struct list entry;
1307 DWORD count;
1308 DWORD idx[13];
1309 } constants_entry;
1310
1311 struct StageState {
1312 DWORD stage;
1313 DWORD state;
1314 };
1315
1316 struct IWineD3DStateBlockImpl
1317 {
1318 /* IUnknown fields */
1319 const IWineD3DStateBlockVtbl *lpVtbl;
1320 LONG ref; /* Note: Ref counting not required */
1321
1322 /* IWineD3DStateBlock information */
1323 IUnknown *parent;
1324 IWineD3DDeviceImpl *wineD3DDevice;
1325 WINED3DSTATEBLOCKTYPE blockType;
1326
1327 /* Array indicating whether things have been set or changed */
1328 SAVEDSTATES changed;
1329 struct list set_vconstantsF;
1330 struct list set_pconstantsF;
1331
1332 /* Drawing - Vertex Shader or FVF related */
1333 DWORD fvf;
1334 /* Vertex Shader Declaration */
1335 IWineD3DVertexDeclaration *vertexDecl;
1336
1337 IWineD3DVertexShader *vertexShader;
1338
1339 /* Vertex Shader Constants */
1340 BOOL vertexShaderConstantB[MAX_CONST_B];
1341 INT vertexShaderConstantI[MAX_CONST_I * 4];
1342 float *vertexShaderConstantF;
1343
1344 /* Stream Source */
1345 BOOL streamIsUP;
1346 UINT streamStride[MAX_STREAMS];
1347 UINT streamOffset[MAX_STREAMS + 1 /* tesselated pseudo-stream */ ];
1348 IWineD3DVertexBuffer *streamSource[MAX_STREAMS];
1349 UINT streamFreq[MAX_STREAMS + 1];
1350 UINT streamFlags[MAX_STREAMS + 1]; /*0 | WINED3DSTREAMSOURCE_INSTANCEDATA | WINED3DSTREAMSOURCE_INDEXEDDATA */
1351
1352 /* Indices */
1353 IWineD3DIndexBuffer* pIndexData;
1354 INT baseVertexIndex;
1355 INT loadBaseVertexIndex; /* non-indexed drawing needs 0 here, indexed baseVertexIndex */
1356
1357 /* Transform */
1358 WINED3DMATRIX transforms[HIGHEST_TRANSFORMSTATE + 1];
1359
1360 /* Light hashmap . Collisions are handled using standard wine double linked lists */
1361 #define LIGHTMAP_SIZE 43 /* Use of a prime number recommended. Set to 1 for a linked list! */
1362 #define LIGHTMAP_HASHFUNC(x) ((x) % LIGHTMAP_SIZE) /* Primitive and simple function */
1363 struct list lightMap[LIGHTMAP_SIZE]; /* Mashmap containing the lights */
1364 PLIGHTINFOEL *activeLights[MAX_ACTIVE_LIGHTS]; /* Map of opengl lights to d3d lights */
1365
1366 /* Clipping */
1367 double clipplane[MAX_CLIPPLANES][4];
1368 WINED3DCLIPSTATUS clip_status;
1369
1370 /* ViewPort */
1371 WINED3DVIEWPORT viewport;
1372
1373 /* Material */
1374 WINED3DMATERIAL material;
1375
1376 /* Pixel Shader */
1377 IWineD3DPixelShader *pixelShader;
1378
1379 /* Pixel Shader Constants */
1380 BOOL pixelShaderConstantB[MAX_CONST_B];
1381 INT pixelShaderConstantI[MAX_CONST_I * 4];
1382 float *pixelShaderConstantF;
1383
1384 /* RenderState */
1385 DWORD renderState[WINEHIGHEST_RENDER_STATE + 1];
1386
1387 /* Texture */
1388 IWineD3DBaseTexture *textures[MAX_COMBINED_SAMPLERS];
1389 int textureDimensions[MAX_COMBINED_SAMPLERS];
1390
1391 /* Texture State Stage */
1392 DWORD textureState[MAX_TEXTURES][WINED3D_HIGHEST_TEXTURE_STATE + 1];
1393 DWORD lowest_disabled_stage;
1394 /* Sampler States */
1395 DWORD samplerState[MAX_COMBINED_SAMPLERS][WINED3D_HIGHEST_SAMPLER_STATE + 1];
1396
1397 /* Current GLSL Shader Program */
1398 struct glsl_shader_prog_link *glsl_program;
1399
1400 /* Scissor test rectangle */
1401 RECT scissorRect;
1402
1403 /* Contained state management */
1404 DWORD contained_render_states[WINEHIGHEST_RENDER_STATE + 1];
1405 unsigned int num_contained_render_states;
1406 DWORD contained_transform_states[HIGHEST_TRANSFORMSTATE + 1];
1407 unsigned int num_contained_transform_states;
1408 DWORD contained_vs_consts_i[MAX_CONST_I];
1409 unsigned int num_contained_vs_consts_i;
1410 DWORD contained_vs_consts_b[MAX_CONST_B];
1411 unsigned int num_contained_vs_consts_b;
1412 DWORD *contained_vs_consts_f;
1413 unsigned int num_contained_vs_consts_f;
1414 DWORD contained_ps_consts_i[MAX_CONST_I];
1415 unsigned int num_contained_ps_consts_i;
1416 DWORD contained_ps_consts_b[MAX_CONST_B];
1417 unsigned int num_contained_ps_consts_b;
1418 DWORD *contained_ps_consts_f;
1419 unsigned int num_contained_ps_consts_f;
1420 struct StageState contained_tss_states[MAX_TEXTURES * (WINED3D_HIGHEST_TEXTURE_STATE)];
1421 unsigned int num_contained_tss_states;
1422 struct StageState contained_sampler_states[MAX_COMBINED_SAMPLERS * WINED3D_HIGHEST_SAMPLER_STATE];
1423 unsigned int num_contained_sampler_states;
1424 };
1425
1426 extern void stateblock_savedstates_set(
1427 IWineD3DStateBlock* iface,
1428 SAVEDSTATES* states,
1429 BOOL value);
1430
1431 extern void stateblock_savedstates_copy(
1432 IWineD3DStateBlock* iface,
1433 SAVEDSTATES* dest,
1434 SAVEDSTATES* source);
1435
1436 extern void stateblock_copy(
1437 IWineD3DStateBlock* destination,
1438 IWineD3DStateBlock* source);
1439
1440 extern const IWineD3DStateBlockVtbl IWineD3DStateBlock_Vtbl;
1441
1442 /*****************************************************************************
1443 * IWineD3DQueryImpl implementation structure (extends IUnknown)
1444 */
1445 typedef struct IWineD3DQueryImpl
1446 {
1447 const IWineD3DQueryVtbl *lpVtbl;
1448 LONG ref; /* Note: Ref counting not required */
1449
1450 IUnknown *parent;
1451 /*TODO: replace with iface usage */
1452 #if 0
1453 IWineD3DDevice *wineD3DDevice;
1454 #else
1455 IWineD3DDeviceImpl *wineD3DDevice;
1456 #endif
1457
1458 /* IWineD3DQuery fields */
1459 WINED3DQUERYTYPE type;
1460 /* TODO: Think about using a IUnknown instead of a void* */
1461 void *extendedData;
1462
1463
1464 } IWineD3DQueryImpl;
1465
1466 extern const IWineD3DQueryVtbl IWineD3DQuery_Vtbl;
1467
1468 /* Datastructures for IWineD3DQueryImpl.extendedData */
1469 typedef struct WineQueryOcclusionData {
1470 GLuint queryId;
1471 WineD3DContext *ctx;
1472 } WineQueryOcclusionData;
1473
1474 typedef struct WineQueryEventData {
1475 GLuint fenceId;
1476 WineD3DContext *ctx;
1477 } WineQueryEventData;
1478
1479 /*****************************************************************************
1480 * IWineD3DSwapChainImpl implementation structure (extends IUnknown)
1481 */
1482
1483 typedef struct IWineD3DSwapChainImpl
1484 {
1485 /*IUnknown part*/
1486 const IWineD3DSwapChainVtbl *lpVtbl;
1487 LONG ref; /* Note: Ref counting not required */
1488
1489 IUnknown *parent;
1490 IWineD3DDeviceImpl *wineD3DDevice;
1491
1492 /* IWineD3DSwapChain fields */
1493 IWineD3DSurface **backBuffer;
1494 IWineD3DSurface *frontBuffer;
1495 BOOL wantsDepthStencilBuffer;
1496 WINED3DPRESENT_PARAMETERS presentParms;
1497 DWORD orig_width, orig_height;
1498 WINED3DFORMAT orig_fmt;
1499
1500 long prev_time, frames; /* Performance tracking */
1501 unsigned int vSyncCounter;
1502
1503 WineD3DContext **context; /* Later a array for multithreading */
1504 unsigned int num_contexts;
1505
1506 HWND win_handle;
1507 } IWineD3DSwapChainImpl;
1508
1509 extern const IWineD3DSwapChainVtbl IWineD3DSwapChain_Vtbl;
1510
1511 WineD3DContext *IWineD3DSwapChainImpl_CreateContextForThread(IWineD3DSwapChain *iface);
1512
1513 /*****************************************************************************
1514 * Utility function prototypes
1515 */
1516
1517 /* Trace routines */
1518 const char* debug_d3dformat(WINED3DFORMAT fmt);
1519 const char* debug_d3ddevicetype(WINED3DDEVTYPE devtype);
1520 const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res);
1521 const char* debug_d3dusage(DWORD usage);
1522 const char* debug_d3dusagequery(DWORD usagequery);
1523 const char* debug_d3ddeclmethod(WINED3DDECLMETHOD method);
1524 const char* debug_d3ddecltype(WINED3DDECLTYPE type);
1525 const char* debug_d3ddeclusage(BYTE usage);
1526 const char* debug_d3dprimitivetype(WINED3DPRIMITIVETYPE PrimitiveType);
1527 const char* debug_d3drenderstate(DWORD state);
1528 const char* debug_d3dsamplerstate(DWORD state);
1529 const char* debug_d3dtexturefiltertype(WINED3DTEXTUREFILTERTYPE filter_type);
1530 const char* debug_d3dtexturestate(DWORD state);
1531 const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype);
1532 const char* debug_d3dpool(WINED3DPOOL pool);
1533 const char *debug_fbostatus(GLenum status);
1534 const char *debug_glerror(GLenum error);
1535 const char *debug_d3dbasis(WINED3DBASISTYPE basis);
1536 const char *debug_d3ddegree(WINED3DDEGREETYPE order);
1537
1538 /* Routines for GL <-> D3D values */
1539 GLenum StencilOp(DWORD op);
1540 GLenum CompareFunc(DWORD func);
1541 void set_tex_op(IWineD3DDevice *iface, BOOL isAlpha, int Stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3);
1542 void set_tex_op_nvrc(IWineD3DDevice *iface, BOOL is_alpha, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3, INT texture_idx);
1543 void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords, BOOL transformed, DWORD coordtype);
1544
1545 void surface_set_compatible_renderbuffer(IWineD3DSurface *iface, unsigned int width, unsigned int height);
1546 GLenum surface_get_gl_buffer(IWineD3DSurface *iface, IWineD3DSwapChain *swapchain);
1547
1548 BOOL getColorBits(WINED3DFORMAT fmt, short *redSize, short *greenSize, short *blueSize, short *alphaSize, short *totalSize);
1549 BOOL getDepthStencilBits(WINED3DFORMAT fmt, short *depthSize, short *stencilSize);
1550
1551 /* Math utils */
1552 void multiply_matrix(WINED3DMATRIX *dest, const WINED3DMATRIX *src1, const WINED3DMATRIX *src2);
1553 unsigned int count_bits(unsigned int mask);
1554
1555 /*****************************************************************************
1556 * To enable calling of inherited functions, requires prototypes
1557 *
1558 * Note: Only require classes which are subclassed, ie resource, basetexture,
1559 */
1560 /*** IUnknown methods ***/
1561 extern HRESULT WINAPI IWineD3DResourceImpl_QueryInterface(IWineD3DResource *iface, REFIID riid, void** ppvObject);
1562 extern ULONG WINAPI IWineD3DResourceImpl_AddRef(IWineD3DResource *iface);
1563 extern ULONG WINAPI IWineD3DResourceImpl_Release(IWineD3DResource *iface);
1564 /*** IWineD3DResource methods ***/
1565 extern HRESULT WINAPI IWineD3DResourceImpl_GetParent(IWineD3DResource *iface, IUnknown **pParent);
1566 extern HRESULT WINAPI IWineD3DResourceImpl_GetDevice(IWineD3DResource *iface, IWineD3DDevice ** ppDevice);
1567 extern HRESULT WINAPI IWineD3DResourceImpl_SetPrivateData(IWineD3DResource *iface, REFGUID refguid, CONST void * pData, DWORD SizeOfData, DWORD Flags);
1568 extern HRESULT WINAPI IWineD3DResourceImpl_GetPrivateData(IWineD3DResource *iface, REFGUID refguid, void * pData, DWORD * pSizeOfData);
1569 extern HRESULT WINAPI IWineD3DResourceImpl_FreePrivateData(IWineD3DResource *iface, REFGUID refguid);
1570 extern DWORD WINAPI IWineD3DResourceImpl_SetPriority(IWineD3DResource *iface, DWORD PriorityNew);
1571 extern DWORD WINAPI IWineD3DResourceImpl_GetPriority(IWineD3DResource *iface);
1572 extern void WINAPI IWineD3DResourceImpl_PreLoad(IWineD3DResource *iface);
1573 extern WINED3DRESOURCETYPE WINAPI IWineD3DResourceImpl_GetType(IWineD3DResource *iface);
1574 /*** class static members ***/
1575 void IWineD3DResourceImpl_CleanUp(IWineD3DResource *iface);
1576
1577 /*** IUnknown methods ***/
1578 extern HRESULT WINAPI IWineD3DBaseTextureImpl_QueryInterface(IWineD3DBaseTexture *iface, REFIID riid, void** ppvObject);
1579 extern ULONG WINAPI IWineD3DBaseTextureImpl_AddRef(IWineD3DBaseTexture *iface);
1580 extern ULONG WINAPI IWineD3DBaseTextureImpl_Release(IWineD3DBaseTexture *iface);
1581 /*** IWineD3DResource methods ***/
1582 extern HRESULT WINAPI IWineD3DBaseTextureImpl_GetParent(IWineD3DBaseTexture *iface, IUnknown **pParent);
1583 extern HRESULT WINAPI IWineD3DBaseTextureImpl_GetDevice(IWineD3DBaseTexture *iface, IWineD3DDevice ** ppDevice);
1584 extern HRESULT WINAPI IWineD3DBaseTextureImpl_SetPrivateData(IWineD3DBaseTexture *iface, REFGUID refguid, CONST void * pData, DWORD SizeOfData, DWORD Flags);
1585 extern HRESULT WINAPI IWineD3DBaseTextureImpl_GetPrivateData(IWineD3DBaseTexture *iface, REFGUID refguid, void * pData, DWORD * pSizeOfData);
1586 extern HRESULT WINAPI IWineD3DBaseTextureImpl_FreePrivateData(IWineD3DBaseTexture *iface, REFGUID refguid);
1587 extern DWORD WINAPI IWineD3DBaseTextureImpl_SetPriority(IWineD3DBaseTexture *iface, DWORD PriorityNew);
1588 extern DWORD WINAPI IWineD3DBaseTextureImpl_GetPriority(IWineD3DBaseTexture *iface);
1589 extern void WINAPI IWineD3DBaseTextureImpl_PreLoad(IWineD3DBaseTexture *iface);
1590 extern WINED3DRESOURCETYPE WINAPI IWineD3DBaseTextureImpl_GetType(IWineD3DBaseTexture *iface);
1591 /*** IWineD3DBaseTexture methods ***/
1592 extern DWORD WINAPI IWineD3DBaseTextureImpl_SetLOD(IWineD3DBaseTexture *iface, DWORD LODNew);
1593 extern DWORD WINAPI IWineD3DBaseTextureImpl_GetLOD(IWineD3DBaseTexture *iface);
1594 extern DWORD WINAPI IWineD3DBaseTextureImpl_GetLevelCount(IWineD3DBaseTexture *iface);
1595 extern HRESULT WINAPI IWineD3DBaseTextureImpl_SetAutoGenFilterType(IWineD3DBaseTexture *iface, WINED3DTEXTUREFILTERTYPE FilterType);
1596 extern WINED3DTEXTUREFILTERTYPE WINAPI IWineD3DBaseTextureImpl_GetAutoGenFilterType(IWineD3DBaseTexture *iface);
1597 extern void WINAPI IWineD3DBaseTextureImpl_GenerateMipSubLevels(IWineD3DBaseTexture *iface);
1598 extern BOOL WINAPI IWineD3DBaseTextureImpl_SetDirty(IWineD3DBaseTexture *iface, BOOL);
1599 extern BOOL WINAPI IWineD3DBaseTextureImpl_GetDirty(IWineD3DBaseTexture *iface);
1600
1601 extern BYTE* WINAPI IWineD3DVertexBufferImpl_GetMemory(IWineD3DVertexBuffer* iface, DWORD iOffset, GLint *vbo);
1602 extern HRESULT WINAPI IWineD3DVertexBufferImpl_ReleaseMemory(IWineD3DVertexBuffer* iface);
1603 extern HRESULT WINAPI IWineD3DBaseTextureImpl_BindTexture(IWineD3DBaseTexture *iface);
1604 extern HRESULT WINAPI IWineD3DBaseTextureImpl_UnBindTexture(IWineD3DBaseTexture *iface);
1605 extern void WINAPI IWineD3DBaseTextureImpl_ApplyStateChanges(IWineD3DBaseTexture *iface, const DWORD textureStates[WINED3D_HIGHEST_TEXTURE_STATE + 1], const DWORD samplerStates[WINED3D_HIGHEST_SAMPLER_STATE + 1]);
1606 /*** class static members ***/
1607 void IWineD3DBaseTextureImpl_CleanUp(IWineD3DBaseTexture *iface);
1608
1609 typedef void (*SHADER_HANDLER) (struct SHADER_OPCODE_ARG*);
1610
1611 /* Struct to maintain a list of GLSL shader programs and their associated pixel and
1612 * vertex shaders. A list of this type is maintained on the DeviceImpl, and is only
1613 * used if the user is using GLSL shaders. */
1614 struct glsl_shader_prog_link {
1615 struct list vshader_entry;
1616 struct list pshader_entry;
1617 GLhandleARB programId;
1618 GLhandleARB *vuniformF_locations;
1619 GLhandleARB *puniformF_locations;
1620 GLhandleARB vuniformI_locations[MAX_CONST_I];
1621 GLhandleARB puniformI_locations[MAX_CONST_I];
1622 GLhandleARB posFixup_location;
1623 GLhandleARB bumpenvmat_location;
1624 GLhandleARB luminancescale_location;
1625 GLhandleARB luminanceoffset_location;
1626 GLhandleARB srgb_comparison_location;
1627 GLhandleARB srgb_mul_low_location;
1628 GLhandleARB ycorrection_location;
1629 GLhandleARB vshader;
1630 GLhandleARB pshader;
1631 };
1632
1633 typedef struct {
1634 GLhandleARB vshader;
1635 GLhandleARB pshader;
1636 } glsl_program_key_t;
1637
1638 /* TODO: Make this dynamic, based on shader limits ? */
1639 #define MAX_REG_ADDR 1
1640 #define MAX_REG_TEMP 32
1641 #define MAX_REG_TEXCRD 8
1642 #define MAX_REG_INPUT 12
1643 #define MAX_REG_OUTPUT 12
1644 #define MAX_ATTRIBS 16
1645 #define MAX_CONST_I 16
1646 #define MAX_CONST_B 16
1647
1648 /* FIXME: This needs to go up to 2048 for
1649 * Shader model 3 according to msdn (and for software shaders) */
1650 #define MAX_LABELS 16
1651
1652 typedef struct semantic {
1653 DWORD usage;
1654 DWORD reg;
1655 } semantic;
1656
1657 typedef struct local_constant {
1658 struct list entry;
1659 unsigned int idx;
1660 DWORD value[4];
1661 } local_constant;
1662
1663 typedef struct shader_reg_maps {
1664
1665 char texcoord[MAX_REG_TEXCRD]; /* pixel < 3.0 */
1666 char temporary[MAX_REG_TEMP]; /* pixel, vertex */
1667 char address[MAX_REG_ADDR]; /* vertex */
1668 char packed_input[MAX_REG_INPUT]; /* pshader >= 3.0 */
1669 char packed_output[MAX_REG_OUTPUT]; /* vertex >= 3.0 */
1670 char attributes[MAX_ATTRIBS]; /* vertex */
1671 char labels[MAX_LABELS]; /* pixel, vertex */
1672
1673 /* Sampler usage tokens
1674 * Use 0 as default (bit 31 is always 1 on a valid token) */
1675 DWORD samplers[max(MAX_FRAGMENT_SAMPLERS, MAX_VERTEX_SAMPLERS)];
1676 char bumpmat, luminanceparams;
1677 char usesnrm, vpos, usesdsy;
1678
1679 /* Whether or not loops are used in this shader, and nesting depth */
1680 unsigned loop_depth;
1681
1682 /* Whether or not this shader uses fog */
1683 char fog;
1684
1685 } shader_reg_maps;
1686
1687 #define SHADER_PGMSIZE 65535
1688 typedef struct SHADER_BUFFER {
1689 char* buffer;
1690 unsigned int bsize;
1691 unsigned int lineNo;
1692 BOOL newline;
1693 } SHADER_BUFFER;
1694
1695 /* Undocumented opcode controls */
1696 #define INST_CONTROLS_SHIFT 16
1697 #define INST_CONTROLS_MASK 0x00ff0000
1698
1699 typedef enum COMPARISON_TYPE {
1700 COMPARISON_GT = 1,
1701 COMPARISON_EQ = 2,
1702 COMPARISON_GE = 3,
1703 COMPARISON_LT = 4,
1704 COMPARISON_NE = 5,
1705 COMPARISON_LE = 6
1706 } COMPARISON_TYPE;
1707
1708 typedef struct SHADER_OPCODE {
1709 unsigned int opcode;
1710 const char* name;
1711 const char* glname;
1712 char dst_token;
1713 CONST UINT num_params;
1714 SHADER_HANDLER hw_fct;
1715 SHADER_HANDLER hw_glsl_fct;
1716 DWORD min_version;
1717 DWORD max_version;
1718 } SHADER_OPCODE;
1719
1720 typedef struct SHADER_OPCODE_ARG {
1721 IWineD3DBaseShader* shader;
1722 shader_reg_maps* reg_maps;
1723 CONST SHADER_OPCODE* opcode;
1724 DWORD opcode_token;
1725 DWORD dst;
1726 DWORD dst_addr;
1727 DWORD predicate;
1728 DWORD src[4];
1729 DWORD src_addr[4];
1730 SHADER_BUFFER* buffer;
1731 } SHADER_OPCODE_ARG;
1732
1733 typedef struct SHADER_LIMITS {
1734 unsigned int temporary;
1735 unsigned int texcoord;
1736 unsigned int sampler;
1737 unsigned int constant_int;
1738 unsigned int constant_float;
1739 unsigned int constant_bool;
1740 unsigned int address;
1741 unsigned int packed_output;
1742 unsigned int packed_input;
1743 unsigned int attributes;
1744 unsigned int label;
1745 } SHADER_LIMITS;
1746
1747 /** Keeps track of details for TEX_M#x# shader opcodes which need to
1748 maintain state information between multiple codes */
1749 typedef struct SHADER_PARSE_STATE {
1750 unsigned int current_row;
1751 DWORD texcoord_w[2];
1752 } SHADER_PARSE_STATE;
1753
1754 /* Base Shader utility functions.
1755 * (may move callers into the same file in the future) */
1756 extern int shader_addline(
1757 SHADER_BUFFER* buffer,
1758 const char* fmt, ...);
1759
1760 extern const SHADER_OPCODE* shader_get_opcode(
1761 IWineD3DBaseShader *iface,
1762 const DWORD code);
1763
1764 extern void shader_delete_constant_list(
1765 struct list* clist);
1766
1767 void delete_glsl_program_entry(IWineD3DDevice *iface, struct glsl_shader_prog_link *entry);
1768
1769 /* Vertex shader utility functions */
1770 extern BOOL vshader_get_input(
1771 IWineD3DVertexShader* iface,
1772 BYTE usage_req, BYTE usage_idx_req,
1773 unsigned int* regnum);
1774
1775 extern BOOL vshader_input_is_color(
1776 IWineD3DVertexShader* iface,
1777 unsigned int regnum);
1778
1779 extern HRESULT allocate_shader_constants(IWineD3DStateBlockImpl* object);
1780
1781 /* ARB_[vertex/fragment]_program helper functions */
1782 extern void shader_arb_load_constants(
1783 IWineD3DDevice* device,
1784 char usePixelShader,
1785 char useVertexShader);
1786
1787 /* ARB shader program Prototypes */
1788 extern void shader_hw_def(SHADER_OPCODE_ARG *arg);
1789
1790 /* ARB pixel shader prototypes */
1791 extern void pshader_hw_bem(SHADER_OPCODE_ARG* arg);
1792 extern void pshader_hw_cnd(SHADER_OPCODE_ARG* arg);
1793 extern void pshader_hw_cmp(SHADER_OPCODE_ARG* arg);
1794 extern void pshader_hw_map2gl(SHADER_OPCODE_ARG* arg);
1795 extern void pshader_hw_tex(SHADER_OPCODE_ARG* arg);
1796 extern void pshader_hw_texcoord(SHADER_OPCODE_ARG* arg);
1797 extern void pshader_hw_texreg2ar(SHADER_OPCODE_ARG* arg);
1798 extern void pshader_hw_texreg2gb(SHADER_OPCODE_ARG* arg);
1799 extern void pshader_hw_texbem(SHADER_OPCODE_ARG* arg);
1800 extern void pshader_hw_texm3x2pad(SHADER_OPCODE_ARG* arg);
1801 extern void pshader_hw_texm3x2tex(SHADER_OPCODE_ARG* arg);
1802 extern void pshader_hw_texm3x3pad(SHADER_OPCODE_ARG* arg);
1803 extern void pshader_hw_texm3x3tex(SHADER_OPCODE_ARG* arg);
1804 extern void pshader_hw_texm3x3spec(SHADER_OPCODE_ARG* arg);
1805 extern void pshader_hw_texm3x3vspec(SHADER_OPCODE_ARG* arg);
1806 extern void pshader_hw_texdepth(SHADER_OPCODE_ARG* arg);
1807 extern void pshader_hw_texkill(SHADER_OPCODE_ARG* arg);
1808 extern void pshader_hw_texdp3tex(SHADER_OPCODE_ARG* arg);
1809 extern void pshader_hw_texdp3(SHADER_OPCODE_ARG* arg);
1810 extern void pshader_hw_texm3x3(SHADER_OPCODE_ARG* arg);
1811 extern void pshader_hw_texm3x2depth(SHADER_OPCODE_ARG* arg);
1812 extern void pshader_hw_dp2add(SHADER_OPCODE_ARG* arg);
1813 extern void pshader_hw_texreg2rgb(SHADER_OPCODE_ARG* arg);
1814
1815 /* ARB vertex / pixel shader common prototypes */
1816 extern void shader_hw_nrm(SHADER_OPCODE_ARG* arg);
1817 extern void shader_hw_sincos(SHADER_OPCODE_ARG* arg);
1818 extern void shader_hw_mnxn(SHADER_OPCODE_ARG* arg);
1819
1820 /* ARB vertex shader prototypes */
1821 extern void vshader_hw_map2gl(SHADER_OPCODE_ARG* arg);
1822 extern void vshader_hw_rsq_rcp(SHADER_OPCODE_ARG* arg);
1823
1824 /* GLSL helper functions */
1825 extern void shader_glsl_add_instruction_modifiers(SHADER_OPCODE_ARG *arg);
1826 extern void shader_glsl_load_constants(
1827 IWineD3DDevice* device,
1828 char usePixelShader,
1829 char useVertexShader);
1830
1831 /** The following translate DirectX pixel/vertex shader opcodes to GLSL lines */
1832 extern void shader_glsl_cross(SHADER_OPCODE_ARG* arg);
1833 extern void shader_glsl_map2gl(SHADER_OPCODE_ARG* arg);
1834 extern void shader_glsl_arith(SHADER_OPCODE_ARG* arg);
1835 extern void shader_glsl_mov(SHADER_OPCODE_ARG* arg);
1836 extern void shader_glsl_mad(SHADER_OPCODE_ARG* arg);
1837 extern void shader_glsl_mnxn(SHADER_OPCODE_ARG* arg);
1838 extern void shader_glsl_lrp(SHADER_OPCODE_ARG* arg);
1839 extern void shader_glsl_dot(SHADER_OPCODE_ARG* arg);
1840 extern void shader_glsl_rcp(SHADER_OPCODE_ARG* arg);
1841 extern void shader_glsl_rsq(SHADER_OPCODE_ARG* arg);
1842 extern void shader_glsl_cnd(SHADER_OPCODE_ARG* arg);
1843 extern void shader_glsl_compare(SHADER_OPCODE_ARG* arg);
1844 extern void shader_glsl_def(SHADER_OPCODE_ARG* arg);
1845 extern void shader_glsl_defi(SHADER_OPCODE_ARG* arg);
1846 extern void shader_glsl_defb(SHADER_OPCODE_ARG* arg);
1847 extern void shader_glsl_expp(SHADER_OPCODE_ARG* arg);
1848 extern void shader_glsl_cmp(SHADER_OPCODE_ARG* arg);
1849 extern void shader_glsl_lit(SHADER_OPCODE_ARG* arg);
1850 extern void shader_glsl_dst(SHADER_OPCODE_ARG* arg);
1851 extern void shader_glsl_sincos(SHADER_OPCODE_ARG* arg);
1852 extern void shader_glsl_loop(SHADER_OPCODE_ARG* arg);
1853 extern void shader_glsl_end(SHADER_OPCODE_ARG* arg);
1854 extern void shader_glsl_if(SHADER_OPCODE_ARG* arg);
1855 extern void shader_glsl_ifc(SHADER_OPCODE_ARG* arg);
1856 extern void shader_glsl_else(SHADER_OPCODE_ARG* arg);
1857 extern void shader_glsl_break(SHADER_OPCODE_ARG* arg);
1858 extern void shader_glsl_breakc(SHADER_OPCODE_ARG* arg);
1859 extern void shader_glsl_rep(SHADER_OPCODE_ARG* arg);
1860 extern void shader_glsl_call(SHADER_OPCODE_ARG* arg);
1861 extern void shader_glsl_callnz(SHADER_OPCODE_ARG* arg);
1862 extern void shader_glsl_label(SHADER_OPCODE_ARG* arg);
1863 extern void shader_glsl_pow(SHADER_OPCODE_ARG* arg);
1864 extern void shader_glsl_log(SHADER_OPCODE_ARG* arg);
1865 extern void shader_glsl_texldl(SHADER_OPCODE_ARG* arg);
1866
1867 /** GLSL Pixel Shader Prototypes */
1868 extern void pshader_glsl_tex(SHADER_OPCODE_ARG* arg);
1869 extern void pshader_glsl_texcoord(SHADER_OPCODE_ARG* arg);
1870 extern void pshader_glsl_texdp3tex(SHADER_OPCODE_ARG* arg);
1871 extern void pshader_glsl_texdp3(SHADER_OPCODE_ARG* arg);
1872 extern void pshader_glsl_texdepth(SHADER_OPCODE_ARG* arg);
1873 extern void pshader_glsl_texm3x2depth(SHADER_OPCODE_ARG* arg);
1874 extern void pshader_glsl_texm3x2pad(SHADER_OPCODE_ARG* arg);
1875 extern void pshader_glsl_texm3x2tex(SHADER_OPCODE_ARG* arg);
1876 extern void pshader_glsl_texm3x3(SHADER_OPCODE_ARG* arg);
1877 extern void pshader_glsl_texm3x3pad(SHADER_OPCODE_ARG* arg);
1878 extern void pshader_glsl_texm3x3tex(SHADER_OPCODE_ARG* arg);
1879 extern void pshader_glsl_texm3x3spec(SHADER_OPCODE_ARG* arg);
1880 extern void pshader_glsl_texm3x3vspec(SHADER_OPCODE_ARG* arg);
1881 extern void pshader_glsl_texkill(SHADER_OPCODE_ARG* arg);
1882 extern void pshader_glsl_texbem(SHADER_OPCODE_ARG* arg);
1883 extern void pshader_glsl_bem(SHADER_OPCODE_ARG* arg);
1884 extern void pshader_glsl_texreg2ar(SHADER_OPCODE_ARG* arg);
1885 extern void pshader_glsl_texreg2gb(SHADER_OPCODE_ARG* arg);
1886 extern void pshader_glsl_texreg2rgb(SHADER_OPCODE_ARG* arg);
1887 extern void pshader_glsl_dp2add(SHADER_OPCODE_ARG* arg);
1888 extern void pshader_glsl_input_pack(
1889 SHADER_BUFFER* buffer,
1890 semantic* semantics_out,
1891 IWineD3DPixelShader *iface);
1892
1893 /*****************************************************************************
1894 * IDirect3DBaseShader implementation structure
1895 */
1896 typedef struct IWineD3DBaseShaderClass
1897 {
1898 DWORD hex_version;
1899 SHADER_LIMITS limits;
1900 SHADER_PARSE_STATE parse_state;
1901 CONST SHADER_OPCODE *shader_ins;
1902 CONST DWORD *function;
1903 UINT functionLength;
1904 GLuint prgId;
1905 BOOL is_compiled;
1906 UINT cur_loop_depth, cur_loop_regno;
1907
1908 /* Type of shader backend */
1909 int shader_mode;
1910
1911 /* Programs this shader is linked with */
1912 struct list linked_programs;
1913
1914 /* Immediate constants (override global ones) */
1915 struct list constantsB;
1916 struct list constantsF;
1917 struct list constantsI;
1918 shader_reg_maps reg_maps;
1919
1920 /* Pixel formats of sampled textures, for format conversion. This
1921 * represents the formats found during compilation, it is not initialized
1922 * on the first parser pass. It is needed to check if the shader
1923 * needs recompilation to adjust the format conversion
1924 */
1925 WINED3DFORMAT sampled_format[MAX_COMBINED_SAMPLERS];
1926 UINT sampled_samplers[MAX_COMBINED_SAMPLERS];
1927 UINT num_sampled_samplers;
1928
1929 UINT recompile_count;
1930
1931 /* Pointer to the parent device */
1932 IWineD3DDevice *device;
1933
1934 } IWineD3DBaseShaderClass;
1935
1936 typedef struct IWineD3DBaseShaderImpl {
1937 /* IUnknown */
1938 const IWineD3DBaseShaderVtbl *lpVtbl;
1939 LONG ref;
1940
1941 /* IWineD3DBaseShader */
1942 IWineD3DBaseShaderClass baseShader;
1943 } IWineD3DBaseShaderImpl;
1944
1945 extern HRESULT shader_get_registers_used(
1946 IWineD3DBaseShader *iface,
1947 shader_reg_maps* reg_maps,
1948 semantic* semantics_in,
1949 semantic* semantics_out,
1950 CONST DWORD* pToken,
1951 IWineD3DStateBlockImpl *stateBlock);
1952
1953 extern void shader_generate_glsl_declarations(
1954 IWineD3DBaseShader *iface,
1955 shader_reg_maps* reg_maps,
1956 SHADER_BUFFER* buffer,
1957 WineD3D_GL_Info* gl_info);
1958
1959 extern void shader_generate_arb_declarations(
1960 IWineD3DBaseShader *iface,
1961 shader_reg_maps* reg_maps,
1962 SHADER_BUFFER* buffer,
1963 WineD3D_GL_Info* gl_info);
1964
1965 extern void shader_generate_main(
1966 IWineD3DBaseShader *iface,
1967 SHADER_BUFFER* buffer,
1968 shader_reg_maps* reg_maps,
1969 CONST DWORD* pFunction);
1970
1971 extern void shader_dump_ins_modifiers(
1972 const DWORD output);
1973
1974 extern void shader_dump_param(
1975 IWineD3DBaseShader *iface,
1976 const DWORD param,
1977 const DWORD addr_token,
1978 int input);
1979
1980 extern void shader_trace_init(
1981 IWineD3DBaseShader *iface,
1982 const DWORD* pFunction);
1983
1984 extern int shader_get_param(
1985 IWineD3DBaseShader* iface,
1986 const DWORD* pToken,
1987 DWORD* param,
1988 DWORD* addr_token);
1989
1990 extern int shader_skip_unrecognized(
1991 IWineD3DBaseShader* iface,
1992 const DWORD* pToken);
1993
1994 extern void print_glsl_info_log(
1995 WineD3D_GL_Info *gl_info,
1996 GLhandleARB obj);
1997
1998 static inline int shader_get_regtype(const DWORD param) {
1999 return (((param & WINED3DSP_REGTYPE_MASK) >> WINED3DSP_REGTYPE_SHIFT) |
2000 ((param & WINED3DSP_REGTYPE_MASK2) >> WINED3DSP_REGTYPE_SHIFT2));
2001 }
2002
2003 extern unsigned int shader_get_float_offset(const DWORD reg);
2004
2005 static inline BOOL shader_is_pshader_version(DWORD token) {
2006 return 0xFFFF0000 == (token & 0xFFFF0000);
2007 }
2008
2009 static inline BOOL shader_is_vshader_version(DWORD token) {
2010 return 0xFFFE0000 == (token & 0xFFFF0000);
2011 }
2012
2013 static inline BOOL shader_is_comment(DWORD token) {
2014 return WINED3DSIO_COMMENT == (token & WINED3DSI_OPCODE_MASK);
2015 }
2016
2017 /* TODO: vFace (ps_3_0) */
2018 static inline BOOL shader_is_scalar(DWORD param) {
2019 DWORD reg_type = shader_get_regtype(param);
2020
2021 switch (reg_type) {
2022 case WINED3DSPR_RASTOUT:
2023 if ((param & WINED3DSP_REGNUM_MASK) != 0) {
2024 /* oFog & oPts */
2025 return TRUE;
2026 }
2027 /* oPos */
2028 return FALSE;
2029
2030 case WINED3DSPR_DEPTHOUT: /* oDepth */
2031 case WINED3DSPR_CONSTBOOL: /* b# */
2032 case WINED3DSPR_LOOP: /* aL */
2033 case WINED3DSPR_PREDICATE: /* p0 */
2034 return TRUE;
2035
2036 default:
2037 return FALSE;
2038 }
2039 }
2040
2041 /* Internally used shader constants. Applications can use constants 0 to GL_LIMITS(vshader_constantsF) - 1,
2042 * so upload them above that
2043 */
2044 #define ARB_SHADER_PRIVCONST_BASE GL_LIMITS(vshader_constantsF)
2045 #define ARB_SHADER_PRIVCONST_POS ARB_SHADER_PRIVCONST_BASE + 0
2046
2047 /*****************************************************************************
2048 * IDirect3DVertexShader implementation structure
2049 */
2050 typedef struct IWineD3DVertexShaderImpl {
2051 /* IUnknown parts*/
2052 const IWineD3DVertexShaderVtbl *lpVtbl;
2053 LONG ref; /* Note: Ref counting not required */
2054
2055 /* IWineD3DBaseShader */
2056 IWineD3DBaseShaderClass baseShader;
2057
2058 /* IWineD3DVertexShaderImpl */
2059 IUnknown *parent;
2060
2061 DWORD usage;
2062
2063 /* Vertex shader input and output semantics */
2064 semantic semantics_in [MAX_ATTRIBS];
2065 semantic semantics_out [MAX_REG_OUTPUT];
2066
2067 /* run time datas... */
2068 VSHADERDATA *data;
2069 UINT min_rel_offset, max_rel_offset;
2070 UINT rel_offset;
2071
2072 #if 0 /* needs reworking */
2073 /* run time datas */
2074 VSHADERINPUTDATA input;
2075 VSHADEROUTPUTDATA output;
2076 #endif
2077 } IWineD3DVertexShaderImpl;
2078 extern const SHADER_OPCODE IWineD3DVertexShaderImpl_shader_ins[];
2079 extern const IWineD3DVertexShaderVtbl IWineD3DVertexShader_Vtbl;
2080
2081 /*****************************************************************************
2082 * IDirect3DPixelShader implementation structure
2083 */
2084
2085 enum vertexprocessing_mode {
2086 fixedfunction,
2087 vertexshader,
2088 pretransformed
2089 };
2090
2091 typedef struct IWineD3DPixelShaderImpl {
2092 /* IUnknown parts */
2093 const IWineD3DPixelShaderVtbl *lpVtbl;
2094 LONG ref; /* Note: Ref counting not required */
2095
2096 /* IWineD3DBaseShader */
2097 IWineD3DBaseShaderClass baseShader;
2098
2099 /* IWineD3DPixelShaderImpl */
2100 IUnknown *parent;
2101
2102 /* Pixel shader input semantics */
2103 semantic semantics_in [MAX_REG_INPUT];
2104 DWORD input_reg_map[MAX_REG_INPUT];
2105 BOOL input_reg_used[MAX_REG_INPUT];
2106
2107 /* run time data */
2108 PSHADERDATA *data;
2109
2110 /* Some information about the shader behavior */
2111 char needsbumpmat;
2112 UINT bumpenvmatconst;
2113 UINT luminanceconst;
2114 char srgb_enabled;
2115 char srgb_mode_hardcoded;
2116 UINT srgb_low_const;
2117 UINT srgb_cmp_const;
2118 char vpos_uniform;
2119 BOOL render_offscreen;
2120 UINT height;
2121 enum vertexprocessing_mode vertexprocessing;
2122
2123 #if 0 /* needs reworking */
2124 PSHADERINPUTDATA input;
2125 PSHADEROUTPUTDATA output;
2126 #endif
2127 } IWineD3DPixelShaderImpl;
2128
2129 extern const SHADER_OPCODE IWineD3DPixelShaderImpl_shader_ins[];
2130 extern const IWineD3DPixelShaderVtbl IWineD3DPixelShader_Vtbl;
2131
2132 /* sRGB correction constants */
2133 static const float srgb_cmp = 0.0031308;
2134 static const float srgb_mul_low = 12.92;
2135 static const float srgb_pow = 0.41666;
2136 static const float srgb_mul_high = 1.055;
2137 static const float srgb_sub_high = 0.055;
2138
2139 /*****************************************************************************
2140 * IWineD3DPalette implementation structure
2141 */
2142 struct IWineD3DPaletteImpl {
2143 /* IUnknown parts */
2144 const IWineD3DPaletteVtbl *lpVtbl;
2145 LONG ref;
2146
2147 IUnknown *parent;
2148 IWineD3DDeviceImpl *wineD3DDevice;
2149
2150 /* IWineD3DPalette */
2151 HPALETTE hpal;
2152 WORD palVersion; /*| */
2153 WORD palNumEntries; /*| LOGPALETTE */
2154 PALETTEENTRY palents[256]; /*| */
2155 /* This is to store the palette in 'screen format' */
2156 int screen_palents[256];
2157 DWORD Flags;
2158 };
2159
2160 extern const IWineD3DPaletteVtbl IWineD3DPalette_Vtbl;
2161 DWORD IWineD3DPaletteImpl_Size(DWORD dwFlags);
2162
2163 /* DirectDraw utility functions */
2164 extern WINED3DFORMAT pixelformat_for_depth(DWORD depth);
2165
2166 /*****************************************************************************
2167 * Pixel format management
2168 */
2169 typedef struct {
2170 WINED3DFORMAT format;
2171 DWORD alphaMask, redMask, greenMask, blueMask;
2172 UINT bpp;
2173 short depthSize, stencilSize;
2174 BOOL isFourcc;
2175 } StaticPixelFormatDesc;
2176
2177 const StaticPixelFormatDesc *getFormatDescEntry(WINED3DFORMAT fmt,
2178 WineD3D_GL_Info *gl_info,
2179 const GlPixelFormatDesc **glDesc);
2180
2181 static inline BOOL use_vs(IWineD3DDeviceImpl *device) {
2182 return (device->vs_selected_mode != SHADER_NONE
2183 && device->stateBlock->vertexShader
2184 && ((IWineD3DVertexShaderImpl *)device->stateBlock->vertexShader)->baseShader.function
2185 && !device->strided_streams.u.s.position_transformed);
2186 }
2187
2188 static inline BOOL use_ps(IWineD3DDeviceImpl *device) {
2189 return (device->ps_selected_mode != SHADER_NONE
2190 && device->stateBlock->pixelShader
2191 && ((IWineD3DPixelShaderImpl *)device->stateBlock->pixelShader)->baseShader.function);
2192 }
2193
2194 void stretch_rect_fbo(IWineD3DDevice *iface, IWineD3DSurface *src_surface, WINED3DRECT *src_rect,
2195 IWineD3DSurface *dst_surface, WINED3DRECT *dst_rect, const WINED3DTEXTUREFILTERTYPE filter, BOOL flip);
2196
2197 #endif
A free Windows-compatible Operating System