?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Use shader_glsl_log() in some more places.
[wine/wine64.git] / dlls / wined3d / glsl_shader.c
blob287109f7290fa4068f7729596216ffb1a9c3e190
1 /*
2 * GLSL pixel and vertex shader implementation
3 *
4 * Copyright 2006 Jason Green
5 * Copyright 2006-2007 Henri Verbeet
6 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 /*
24 * D3D shader asm has swizzles on source parameters, and write masks for
25 * destination parameters. GLSL uses swizzles for both. The result of this is
26 * that for example "mov dst.xw, src.zyxw" becomes "dst.xw = src.zw" in GLSL.
27 * Ie, to generate a proper GLSL source swizzle, we need to take the D3D write
28 * mask for the destination parameter into account.
29 */
30
31 #include "config.h"
32 #include <stdio.h>
33 #include "wined3d_private.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
36 WINE_DECLARE_DEBUG_CHANNEL(d3d_constants);
37 WINE_DECLARE_DEBUG_CHANNEL(d3d_caps);
38
39 #define GLINFO_LOCATION (*gl_info)
40
41 typedef struct {
42 char reg_name[150];
43 char mask_str[6];
44 } glsl_dst_param_t;
45
46 typedef struct {
47 char reg_name[150];
48 char param_str[100];
49 } glsl_src_param_t;
50
51 typedef struct {
52 const char *name;
53 DWORD coord_mask;
54 } glsl_sample_function_t;
55
56 /* GLSL shader private data */
57 struct shader_glsl_priv {
58 struct hash_table_t *glsl_program_lookup;
59 struct glsl_shader_prog_link *glsl_program;
60 GLhandleARB depth_blt_glsl_program_id;
61 };
62
63 /* Struct to maintain data about a linked GLSL program */
64 struct glsl_shader_prog_link {
65 struct list vshader_entry;
66 struct list pshader_entry;
67 GLhandleARB programId;
68 GLhandleARB *vuniformF_locations;
69 GLhandleARB *puniformF_locations;
70 GLhandleARB vuniformI_locations[MAX_CONST_I];
71 GLhandleARB puniformI_locations[MAX_CONST_I];
72 GLhandleARB posFixup_location;
73 GLhandleARB bumpenvmat_location[MAX_TEXTURES];
74 GLhandleARB luminancescale_location[MAX_TEXTURES];
75 GLhandleARB luminanceoffset_location[MAX_TEXTURES];
76 GLhandleARB srgb_comparison_location;
77 GLhandleARB srgb_mul_low_location;
78 GLhandleARB ycorrection_location;
79 GLenum vertex_color_clamp;
80 GLhandleARB vshader;
81 GLhandleARB pshader;
82 };
83
84 typedef struct {
85 GLhandleARB vshader;
86 GLhandleARB pshader;
87 } glsl_program_key_t;
88
89
90 /** Prints the GLSL info log which will contain error messages if they exist */
91 static void print_glsl_info_log(WineD3D_GL_Info *gl_info, GLhandleARB obj) {
92 int infologLength = 0;
93 char *infoLog;
94 int i;
95 BOOL is_spam;
96
97 const char *spam[] = {
98 "Vertex shader was successfully compiled to run on hardware.\n", /* fglrx */
99 "Fragment shader was successfully compiled to run on hardware.\n", /* fglrx */
100 "Fragment shader(s) linked, vertex shader(s) linked. \n ", /* fglrx, with \n */
101 "Fragment shader(s) linked, vertex shader(s) linked.", /* fglrx, no \n */
102 "Vertex shader(s) linked, no fragment shader(s) defined. \n ", /* fglrx, with \n */
103 "Vertex shader(s) linked, no fragment shader(s) defined.", /* fglrx, no \n */
104 "Fragment shader was successfully compiled to run on hardware.\nWARNING: 0:1: extension 'GL_ARB_draw_buffers' is not supported",
105 "Fragment shader(s) linked, no vertex shader(s) defined.", /* fglrx, no \n */
106 "Fragment shader(s) linked, no vertex shader(s) defined. \n ", /* fglrx, with \n */
107 "WARNING: 0:2: extension 'GL_ARB_draw_buffers' is not supported\n" /* MacOS ati */
108 };
109
110 GL_EXTCALL(glGetObjectParameterivARB(obj,
111 GL_OBJECT_INFO_LOG_LENGTH_ARB,
112 &infologLength));
113
114 /* A size of 1 is just a null-terminated string, so the log should be bigger than
115 * that if there are errors. */
116 if (infologLength > 1)
117 {
118 /* Fglrx doesn't terminate the string properly, but it tells us the proper length.
119 * So use HEAP_ZERO_MEMORY to avoid uninitialized bytes
120 */
121 infoLog = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, infologLength);
122 GL_EXTCALL(glGetInfoLogARB(obj, infologLength, NULL, infoLog));
123 is_spam = FALSE;
124
125 for(i = 0; i < sizeof(spam) / sizeof(spam[0]); i++) {
126 if(strcmp(infoLog, spam[i]) == 0) {
127 is_spam = TRUE;
128 break;
129 }
130 }
131 if(is_spam) {
132 TRACE("Spam received from GLSL shader #%u: %s\n", obj, debugstr_a(infoLog));
133 } else {
134 FIXME("Error received from GLSL shader #%u: %s\n", obj, debugstr_a(infoLog));
135 }
136 HeapFree(GetProcessHeap(), 0, infoLog);
137 }
138 }
139
140 /**
141 * Loads (pixel shader) samplers
142 */
143 static void shader_glsl_load_psamplers(
144 WineD3D_GL_Info *gl_info,
145 IWineD3DStateBlock* iface,
146 GLhandleARB programId) {
147
148 IWineD3DStateBlockImpl* stateBlock = (IWineD3DStateBlockImpl*) iface;
149 GLhandleARB name_loc;
150 int i;
151 char sampler_name[20];
152
153 for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i) {
154 snprintf(sampler_name, sizeof(sampler_name), "Psampler%d", i);
155 name_loc = GL_EXTCALL(glGetUniformLocationARB(programId, sampler_name));
156 if (name_loc != -1) {
157 int mapped_unit = stateBlock->wineD3DDevice->texUnitMap[i];
158 if (mapped_unit != -1 && mapped_unit < GL_LIMITS(fragment_samplers)) {
159 TRACE("Loading %s for texture %d\n", sampler_name, mapped_unit);
160 GL_EXTCALL(glUniform1iARB(name_loc, mapped_unit));
161 checkGLcall("glUniform1iARB");
162 } else {
163 ERR("Trying to load sampler %s on unsupported unit %d\n", sampler_name, mapped_unit);
164 }
165 }
166 }
167 }
168
169 static void shader_glsl_load_vsamplers(WineD3D_GL_Info *gl_info, IWineD3DStateBlock* iface, GLhandleARB programId) {
170 IWineD3DStateBlockImpl* stateBlock = (IWineD3DStateBlockImpl*) iface;
171 GLhandleARB name_loc;
172 char sampler_name[20];
173 int i;
174
175 for (i = 0; i < MAX_VERTEX_SAMPLERS; ++i) {
176 snprintf(sampler_name, sizeof(sampler_name), "Vsampler%d", i);
177 name_loc = GL_EXTCALL(glGetUniformLocationARB(programId, sampler_name));
178 if (name_loc != -1) {
179 int mapped_unit = stateBlock->wineD3DDevice->texUnitMap[MAX_FRAGMENT_SAMPLERS + i];
180 if (mapped_unit != -1 && mapped_unit < GL_LIMITS(combined_samplers)) {
181 TRACE("Loading %s for texture %d\n", sampler_name, mapped_unit);
182 GL_EXTCALL(glUniform1iARB(name_loc, mapped_unit));
183 checkGLcall("glUniform1iARB");
184 } else {
185 ERR("Trying to load sampler %s on unsupported unit %d\n", sampler_name, mapped_unit);
186 }
187 }
188 }
189 }
190
191 /**
192 * Loads floating point constants (aka uniforms) into the currently set GLSL program.
193 * When constant_list == NULL, it will load all the constants.
194 */
195 static void shader_glsl_load_constantsF(IWineD3DBaseShaderImpl* This, WineD3D_GL_Info *gl_info,
196 unsigned int max_constants, float* constants, GLhandleARB *constant_locations,
197 struct list *constant_list) {
198 constants_entry *constant;
199 local_constant* lconst;
200 GLhandleARB tmp_loc;
201 DWORD i, j, k;
202 DWORD *idx;
203
204 if (TRACE_ON(d3d_shader)) {
205 LIST_FOR_EACH_ENTRY(constant, constant_list, constants_entry, entry) {
206 idx = constant->idx;
207 j = constant->count;
208 while (j--) {
209 i = *idx++;
210 tmp_loc = constant_locations[i];
211 if (tmp_loc != -1) {
212 TRACE_(d3d_constants)("Loading constants %i: %f, %f, %f, %f\n", i,
213 constants[i * 4 + 0], constants[i * 4 + 1],
214 constants[i * 4 + 2], constants[i * 4 + 3]);
215 }
216 }
217 }
218 }
219
220 /* 1.X pshaders have the constants clamped to [-1;1] implicitly. */
221 if(WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) == 1 &&
222 shader_is_pshader_version(This->baseShader.hex_version)) {
223 float lcl_const[4];
224
225 LIST_FOR_EACH_ENTRY(constant, constant_list, constants_entry, entry) {
226 idx = constant->idx;
227 j = constant->count;
228 while (j--) {
229 i = *idx++;
230 tmp_loc = constant_locations[i];
231 if (tmp_loc != -1) {
232 /* We found this uniform name in the program - go ahead and send the data */
233 k = i * 4;
234 if(constants[k + 0] < -1.0) lcl_const[0] = -1.0;
235 else if(constants[k + 0] > 1.0) lcl_const[0] = 1.0;
236 else lcl_const[0] = constants[k + 0];
237 if(constants[k + 1] < -1.0) lcl_const[1] = -1.0;
238 else if(constants[k + 1] > 1.0) lcl_const[1] = 1.0;
239 else lcl_const[1] = constants[k + 1];
240 if(constants[k + 2] < -1.0) lcl_const[2] = -1.0;
241 else if(constants[k + 2] > 1.0) lcl_const[2] = 1.0;
242 else lcl_const[2] = constants[k + 2];
243 if(constants[k + 3] < -1.0) lcl_const[3] = -1.0;
244 else if(constants[k + 3] > 1.0) lcl_const[3] = 1.0;
245 else lcl_const[3] = constants[k + 3];
246
247 GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, lcl_const));
248 }
249 }
250 }
251 } else {
252 LIST_FOR_EACH_ENTRY(constant, constant_list, constants_entry, entry) {
253 idx = constant->idx;
254 j = constant->count;
255 while (j--) {
256 i = *idx++;
257 tmp_loc = constant_locations[i];
258 if (tmp_loc != -1) {
259 /* We found this uniform name in the program - go ahead and send the data */
260 GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, constants + (i * 4)));
261 }
262 }
263 }
264 }
265 checkGLcall("glUniform4fvARB()");
266
267 if(!This->baseShader.load_local_constsF) {
268 TRACE("No need to load local float constants for this shader\n");
269 return;
270 }
271
272 /* Load immediate constants */
273 if (TRACE_ON(d3d_shader)) {
274 LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
275 tmp_loc = constant_locations[lconst->idx];
276 if (tmp_loc != -1) {
277 GLfloat* values = (GLfloat*)lconst->value;
278 TRACE_(d3d_constants)("Loading local constants %i: %f, %f, %f, %f\n", lconst->idx,
279 values[0], values[1], values[2], values[3]);
280 }
281 }
282 }
283 /* Immediate constants are clamped to [-1;1] at shader creation time if needed */
284 LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
285 tmp_loc = constant_locations[lconst->idx];
286 if (tmp_loc != -1) {
287 /* We found this uniform name in the program - go ahead and send the data */
288 GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, (GLfloat*)lconst->value));
289 }
290 }
291 checkGLcall("glUniform4fvARB()");
292 }
293
294 /**
295 * Loads integer constants (aka uniforms) into the currently set GLSL program.
296 * When @constants_set == NULL, it will load all the constants.
297 */
298 static void shader_glsl_load_constantsI(
299 IWineD3DBaseShaderImpl* This,
300 WineD3D_GL_Info *gl_info,
301 GLhandleARB programId,
302 GLhandleARB locations[MAX_CONST_I],
303 unsigned max_constants,
304 int* constants,
305 BOOL* constants_set) {
306
307 int i;
308 struct list* ptr;
309
310 for (i=0; i<max_constants; ++i) {
311 if (NULL == constants_set || constants_set[i]) {
312
313 TRACE_(d3d_constants)("Loading constants %i: %i, %i, %i, %i\n",
314 i, constants[i*4], constants[i*4+1], constants[i*4+2], constants[i*4+3]);
315
316 /* We found this uniform name in the program - go ahead and send the data */
317 GL_EXTCALL(glUniform4ivARB(locations[i], 1, &constants[i*4]));
318 checkGLcall("glUniform4ivARB");
319 }
320 }
321
322 /* Load immediate constants */
323 ptr = list_head(&This->baseShader.constantsI);
324 while (ptr) {
325 local_constant* lconst = LIST_ENTRY(ptr, struct local_constant, entry);
326 unsigned int idx = lconst->idx;
327 GLint* values = (GLint*) lconst->value;
328
329 TRACE_(d3d_constants)("Loading local constants %i: %i, %i, %i, %i\n", idx,
330 values[0], values[1], values[2], values[3]);
331
332 /* We found this uniform name in the program - go ahead and send the data */
333 GL_EXTCALL(glUniform4ivARB(locations[idx], 1, values));
334 checkGLcall("glUniform4ivARB");
335 ptr = list_next(&This->baseShader.constantsI, ptr);
336 }
337 }
338
339 /**
340 * Loads boolean constants (aka uniforms) into the currently set GLSL program.
341 * When @constants_set == NULL, it will load all the constants.
342 */
343 static void shader_glsl_load_constantsB(
344 IWineD3DBaseShaderImpl* This,
345 WineD3D_GL_Info *gl_info,
346 GLhandleARB programId,
347 unsigned max_constants,
348 BOOL* constants,
349 BOOL* constants_set) {
350
351 GLhandleARB tmp_loc;
352 int i;
353 char tmp_name[8];
354 char is_pshader = shader_is_pshader_version(This->baseShader.hex_version);
355 const char* prefix = is_pshader? "PB":"VB";
356 struct list* ptr;
357
358 for (i=0; i<max_constants; ++i) {
359 if (NULL == constants_set || constants_set[i]) {
360
361 TRACE_(d3d_constants)("Loading constants %i: %i;\n", i, constants[i]);
362
363 /* TODO: Benchmark and see if it would be beneficial to store the
364 * locations of the constants to avoid looking up each time */
365 snprintf(tmp_name, sizeof(tmp_name), "%s[%i]", prefix, i);
366 tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
367 if (tmp_loc != -1) {
368 /* We found this uniform name in the program - go ahead and send the data */
369 GL_EXTCALL(glUniform1ivARB(tmp_loc, 1, &constants[i]));
370 checkGLcall("glUniform1ivARB");
371 }
372 }
373 }
374
375 /* Load immediate constants */
376 ptr = list_head(&This->baseShader.constantsB);
377 while (ptr) {
378 local_constant* lconst = LIST_ENTRY(ptr, struct local_constant, entry);
379 unsigned int idx = lconst->idx;
380 GLint* values = (GLint*) lconst->value;
381
382 TRACE_(d3d_constants)("Loading local constants %i: %i\n", idx, values[0]);
383
384 snprintf(tmp_name, sizeof(tmp_name), "%s[%i]", prefix, idx);
385 tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
386 if (tmp_loc != -1) {
387 /* We found this uniform name in the program - go ahead and send the data */
388 GL_EXTCALL(glUniform1ivARB(tmp_loc, 1, values));
389 checkGLcall("glUniform1ivARB");
390 }
391 ptr = list_next(&This->baseShader.constantsB, ptr);
392 }
393 }
394
395
396
397 /**
398 * Loads the app-supplied constants into the currently set GLSL program.
399 */
400 static void shader_glsl_load_constants(
401 IWineD3DDevice* device,
402 char usePixelShader,
403 char useVertexShader) {
404
405 IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) device;
406 struct shader_glsl_priv *priv = (struct shader_glsl_priv *)deviceImpl->shader_priv;
407 IWineD3DStateBlockImpl* stateBlock = deviceImpl->stateBlock;
408 WineD3D_GL_Info *gl_info = &deviceImpl->adapter->gl_info;
409
410 GLhandleARB *constant_locations;
411 struct list *constant_list;
412 GLhandleARB programId;
413 struct glsl_shader_prog_link *prog = priv->glsl_program;
414 unsigned int i;
415
416 if (!prog) {
417 /* No GLSL program set - nothing to do. */
418 return;
419 }
420 programId = prog->programId;
421
422 if (useVertexShader) {
423 IWineD3DBaseShaderImpl* vshader = (IWineD3DBaseShaderImpl*) stateBlock->vertexShader;
424
425 constant_locations = prog->vuniformF_locations;
426 constant_list = &stateBlock->set_vconstantsF;
427
428 /* Load DirectX 9 float constants/uniforms for vertex shader */
429 shader_glsl_load_constantsF(vshader, gl_info, GL_LIMITS(vshader_constantsF),
430 stateBlock->vertexShaderConstantF, constant_locations, constant_list);
431
432 /* Load DirectX 9 integer constants/uniforms for vertex shader */
433 shader_glsl_load_constantsI(vshader, gl_info, programId,
434 prog->vuniformI_locations, MAX_CONST_I,
435 stateBlock->vertexShaderConstantI,
436 stateBlock->changed.vertexShaderConstantsI);
437
438 /* Load DirectX 9 boolean constants/uniforms for vertex shader */
439 shader_glsl_load_constantsB(vshader, gl_info, programId, MAX_CONST_B,
440 stateBlock->vertexShaderConstantB,
441 stateBlock->changed.vertexShaderConstantsB);
442
443 /* Upload the position fixup params */
444 GL_EXTCALL(glUniform4fvARB(prog->posFixup_location, 1, &deviceImpl->posFixup[0]));
445 checkGLcall("glUniform4fvARB");
446 }
447
448 if (usePixelShader) {
449
450 IWineD3DBaseShaderImpl* pshader = (IWineD3DBaseShaderImpl*) stateBlock->pixelShader;
451
452 constant_locations = prog->puniformF_locations;
453 constant_list = &stateBlock->set_pconstantsF;
454
455 /* Load DirectX 9 float constants/uniforms for pixel shader */
456 shader_glsl_load_constantsF(pshader, gl_info, GL_LIMITS(pshader_constantsF),
457 stateBlock->pixelShaderConstantF, constant_locations, constant_list);
458
459 /* Load DirectX 9 integer constants/uniforms for pixel shader */
460 shader_glsl_load_constantsI(pshader, gl_info, programId,
461 prog->puniformI_locations, MAX_CONST_I,
462 stateBlock->pixelShaderConstantI,
463 stateBlock->changed.pixelShaderConstantsI);
464
465 /* Load DirectX 9 boolean constants/uniforms for pixel shader */
466 shader_glsl_load_constantsB(pshader, gl_info, programId, MAX_CONST_B,
467 stateBlock->pixelShaderConstantB,
468 stateBlock->changed.pixelShaderConstantsB);
469
470 /* Upload the environment bump map matrix if needed. The needsbumpmat member specifies the texture stage to load the matrix from.
471 * It can't be 0 for a valid texbem instruction.
472 */
473 for(i = 0; i < ((IWineD3DPixelShaderImpl *) pshader)->numbumpenvmatconsts; i++) {
474 IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *) pshader;
475 int stage = ps->luminanceconst[i].texunit;
476
477 float *data = (float *) &stateBlock->textureState[(int) ps->bumpenvmatconst[i].texunit][WINED3DTSS_BUMPENVMAT00];
478 GL_EXTCALL(glUniformMatrix2fvARB(prog->bumpenvmat_location[i], 1, 0, data));
479 checkGLcall("glUniformMatrix2fvARB");
480
481 /* texbeml needs the luminance scale and offset too. If texbeml is used, needsbumpmat
482 * is set too, so we can check that in the needsbumpmat check
483 */
484 if(ps->baseShader.reg_maps.luminanceparams[stage]) {
485 GLfloat *scale = (GLfloat *) &stateBlock->textureState[stage][WINED3DTSS_BUMPENVLSCALE];
486 GLfloat *offset = (GLfloat *) &stateBlock->textureState[stage][WINED3DTSS_BUMPENVLOFFSET];
487
488 GL_EXTCALL(glUniform1fvARB(prog->luminancescale_location[i], 1, scale));
489 checkGLcall("glUniform1fvARB");
490 GL_EXTCALL(glUniform1fvARB(prog->luminanceoffset_location[i], 1, offset));
491 checkGLcall("glUniform1fvARB");
492 }
493 }
494
495 if(((IWineD3DPixelShaderImpl *) pshader)->srgb_enabled &&
496 !((IWineD3DPixelShaderImpl *) pshader)->srgb_mode_hardcoded) {
497 float comparison[4];
498 float mul_low[4];
499
500 if(stateBlock->renderState[WINED3DRS_SRGBWRITEENABLE]) {
501 comparison[0] = srgb_cmp; comparison[1] = srgb_cmp;
502 comparison[2] = srgb_cmp; comparison[3] = srgb_cmp;
503
504 mul_low[0] = srgb_mul_low; mul_low[1] = srgb_mul_low;
505 mul_low[2] = srgb_mul_low; mul_low[3] = srgb_mul_low;
506 } else {
507 comparison[0] = 1.0 / 0.0; comparison[1] = 1.0 / 0.0;
508 comparison[2] = 1.0 / 0.0; comparison[3] = 1.0 / 0.0;
509
510 mul_low[0] = 1.0; mul_low[1] = 1.0;
511 mul_low[2] = 1.0; mul_low[3] = 1.0;
512 }
513
514 GL_EXTCALL(glUniform4fvARB(prog->srgb_comparison_location, 1, comparison));
515 GL_EXTCALL(glUniform4fvARB(prog->srgb_mul_low_location, 1, mul_low));
516 }
517 if(((IWineD3DPixelShaderImpl *) pshader)->vpos_uniform) {
518 float correction_params[4];
519 if(deviceImpl->render_offscreen) {
520 correction_params[0] = 0.0;
521 correction_params[1] = 1.0;
522 } else {
523 /* position is window relative, not viewport relative */
524 correction_params[0] = ((IWineD3DSurfaceImpl *) deviceImpl->render_targets[0])->currentDesc.Height;
525 correction_params[1] = -1.0;
526 }
527 GL_EXTCALL(glUniform4fvARB(prog->ycorrection_location, 1, correction_params));
528 }
529 }
530 }
531
532 /** Generate the variable & register declarations for the GLSL output target */
533 static void shader_generate_glsl_declarations(
534 IWineD3DBaseShader *iface,
535 shader_reg_maps* reg_maps,
536 SHADER_BUFFER* buffer,
537 WineD3D_GL_Info* gl_info) {
538
539 IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
540 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device;
541 int i;
542 unsigned int extra_constants_needed = 0;
543 local_constant* lconst;
544
545 /* There are some minor differences between pixel and vertex shaders */
546 char pshader = shader_is_pshader_version(This->baseShader.hex_version);
547 char prefix = pshader ? 'P' : 'V';
548
549 /* Prototype the subroutines */
550 for (i = 0; i < This->baseShader.limits.label; i++) {
551 if (reg_maps->labels[i])
552 shader_addline(buffer, "void subroutine%u();\n", i);
553 }
554
555 /* Declare the constants (aka uniforms) */
556 if (This->baseShader.limits.constant_float > 0) {
557 unsigned max_constantsF = min(This->baseShader.limits.constant_float,
558 (pshader ? GL_LIMITS(pshader_constantsF) : GL_LIMITS(vshader_constantsF)));
559 shader_addline(buffer, "uniform vec4 %cC[%u];\n", prefix, max_constantsF);
560 }
561
562 if (This->baseShader.limits.constant_int > 0)
563 shader_addline(buffer, "uniform ivec4 %cI[%u];\n", prefix, This->baseShader.limits.constant_int);
564
565 if (This->baseShader.limits.constant_bool > 0)
566 shader_addline(buffer, "uniform bool %cB[%u];\n", prefix, This->baseShader.limits.constant_bool);
567
568 if(!pshader) {
569 shader_addline(buffer, "uniform vec4 posFixup;\n");
570 /* Predeclaration; This function is added at link time based on the pixel shader.
571 * VS 3.0 shaders have an array OUT[] the shader writes to, earlier versions don't have
572 * that. We know the input to the reorder function at vertex shader compile time, so
573 * we can deal with that. The reorder function for a 1.x and 2.x vertex shader can just
574 * read gl_FrontColor. The output depends on the pixel shader. The reorder function for a
575 * 1.x and 2.x pshader or for fixed function will write gl_FrontColor, and for a 3.0 shader
576 * it will write to the varying array. Here we depend on the shader optimizer on sorting that
577 * out. The nvidia driver only does that if the parameter is inout instead of out, hence the
578 * inout.
579 */
580 if(This->baseShader.hex_version >= WINED3DVS_VERSION(3, 0)) {
581 shader_addline(buffer, "void order_ps_input(in vec4[%u]);\n", MAX_REG_OUTPUT);
582 } else {
583 shader_addline(buffer, "void order_ps_input();\n");
584 }
585 } else {
586 IWineD3DPixelShaderImpl *ps_impl = (IWineD3DPixelShaderImpl *) This;
587
588 ps_impl->numbumpenvmatconsts = 0;
589 for(i = 0; i < (sizeof(reg_maps->bumpmat) / sizeof(reg_maps->bumpmat[0])); i++) {
590 if(!reg_maps->bumpmat[i]) {
591 continue;
592 }
593
594 ps_impl->bumpenvmatconst[(int) ps_impl->numbumpenvmatconsts].texunit = i;
595 shader_addline(buffer, "uniform mat2 bumpenvmat%d;\n", i);
596
597 if(reg_maps->luminanceparams) {
598 ps_impl->luminanceconst[(int) ps_impl->numbumpenvmatconsts].texunit = i;
599 shader_addline(buffer, "uniform float luminancescale%d;\n", i);
600 shader_addline(buffer, "uniform float luminanceoffset%d;\n", i);
601 extra_constants_needed++;
602 } else {
603 ps_impl->luminanceconst[(int) ps_impl->numbumpenvmatconsts].texunit = -1;
604 }
605
606 extra_constants_needed++;
607 ps_impl->numbumpenvmatconsts++;
608 }
609
610 if(device->stateBlock->renderState[WINED3DRS_SRGBWRITEENABLE]) {
611 ps_impl->srgb_enabled = 1;
612 if(This->baseShader.limits.constant_float + extra_constants_needed + 1 < GL_LIMITS(pshader_constantsF)) {
613 shader_addline(buffer, "uniform vec4 srgb_mul_low;\n");
614 shader_addline(buffer, "uniform vec4 srgb_comparison;\n");
615 ps_impl->srgb_mode_hardcoded = 0;
616 extra_constants_needed++;
617 } else {
618 ps_impl->srgb_mode_hardcoded = 1;
619 shader_addline(buffer, "const vec4 srgb_mul_low = vec4(%f, %f, %f, %f);\n",
620 srgb_mul_low, srgb_mul_low, srgb_mul_low, srgb_mul_low);
621 shader_addline(buffer, "const vec4 srgb_comparison = vec4(%f, %f, %f, %f);\n",
622 srgb_cmp, srgb_cmp, srgb_cmp, srgb_cmp);
623 }
624 } else {
625 IWineD3DPixelShaderImpl *ps_impl = (IWineD3DPixelShaderImpl *) This;
626
627 /* Do not write any srgb fixup into the shader to save shader size and processing time.
628 * As a consequence, we can't toggle srgb write on without recompilation
629 */
630 ps_impl->srgb_enabled = 0;
631 ps_impl->srgb_mode_hardcoded = 1;
632 }
633 if(reg_maps->vpos || reg_maps->usesdsy) {
634 if(This->baseShader.limits.constant_float + extra_constants_needed + 1 < GL_LIMITS(pshader_constantsF)) {
635 shader_addline(buffer, "uniform vec4 ycorrection;\n");
636 ((IWineD3DPixelShaderImpl *) This)->vpos_uniform = 1;
637 extra_constants_needed++;
638 } else {
639 /* This happens because we do not have proper tracking of the constant registers that are
640 * actually used, only the max limit of the shader version
641 */
642 FIXME("Cannot find a free uniform for vpos correction params\n");
643 shader_addline(buffer, "const vec4 ycorrection = vec4(%f, %f, 0.0, 0.0);\n",
644 device->render_offscreen ? 0.0 : ((IWineD3DSurfaceImpl *) device->render_targets[0])->currentDesc.Height,
645 device->render_offscreen ? 1.0 : -1.0);
646 }
647 shader_addline(buffer, "vec4 vpos;\n");
648 }
649 }
650
651 /* Declare texture samplers */
652 for (i = 0; i < This->baseShader.limits.sampler; i++) {
653 if (reg_maps->samplers[i]) {
654
655 DWORD stype = reg_maps->samplers[i] & WINED3DSP_TEXTURETYPE_MASK;
656 switch (stype) {
657
658 case WINED3DSTT_1D:
659 shader_addline(buffer, "uniform sampler1D %csampler%u;\n", prefix, i);
660 break;
661 case WINED3DSTT_2D:
662 if(device->stateBlock->textures[i] &&
663 IWineD3DBaseTexture_GetTextureDimensions(device->stateBlock->textures[i]) == GL_TEXTURE_RECTANGLE_ARB) {
664 shader_addline(buffer, "uniform sampler2DRect %csampler%u;\n", prefix, i);
665 } else {
666 shader_addline(buffer, "uniform sampler2D %csampler%u;\n", prefix, i);
667 }
668 break;
669 case WINED3DSTT_CUBE:
670 shader_addline(buffer, "uniform samplerCube %csampler%u;\n", prefix, i);
671 break;
672 case WINED3DSTT_VOLUME:
673 shader_addline(buffer, "uniform sampler3D %csampler%u;\n", prefix, i);
674 break;
675 default:
676 shader_addline(buffer, "uniform unsupported_sampler %csampler%u;\n", prefix, i);
677 FIXME("Unrecognized sampler type: %#x\n", stype);
678 break;
679 }
680 }
681 }
682
683 /* Declare address variables */
684 for (i = 0; i < This->baseShader.limits.address; i++) {
685 if (reg_maps->address[i])
686 shader_addline(buffer, "ivec4 A%d;\n", i);
687 }
688
689 /* Declare texture coordinate temporaries and initialize them */
690 for (i = 0; i < This->baseShader.limits.texcoord; i++) {
691 if (reg_maps->texcoord[i])
692 shader_addline(buffer, "vec4 T%u = gl_TexCoord[%u];\n", i, i);
693 }
694
695 /* Declare input register varyings. Only pixel shader, vertex shaders have that declared in the
696 * helper function shader that is linked in at link time
697 */
698 if(pshader && This->baseShader.hex_version >= WINED3DPS_VERSION(3, 0)) {
699 if(use_vs(device)) {
700 shader_addline(buffer, "varying vec4 IN[%u];\n", GL_LIMITS(glsl_varyings) / 4);
701 } else {
702 /* TODO: Write a replacement shader for the fixed function vertex pipeline, so this isn't needed.
703 * For fixed function vertex processing + 3.0 pixel shader we need a separate function in the
704 * pixel shader that reads the fixed function color into the packed input registers.
705 */
706 shader_addline(buffer, "vec4 IN[%u];\n", GL_LIMITS(glsl_varyings) / 4);
707 }
708 }
709
710 /* Declare output register temporaries */
711 if(This->baseShader.limits.packed_output) {
712 shader_addline(buffer, "vec4 OUT[%u];\n", This->baseShader.limits.packed_output);
713 }
714
715 /* Declare temporary variables */
716 for(i = 0; i < This->baseShader.limits.temporary; i++) {
717 if (reg_maps->temporary[i])
718 shader_addline(buffer, "vec4 R%u;\n", i);
719 }
720
721 /* Declare attributes */
722 for (i = 0; i < This->baseShader.limits.attributes; i++) {
723 if (reg_maps->attributes[i])
724 shader_addline(buffer, "attribute vec4 attrib%i;\n", i);
725 }
726
727 /* Declare loop registers aLx */
728 for (i = 0; i < reg_maps->loop_depth; i++) {
729 shader_addline(buffer, "int aL%u;\n", i);
730 shader_addline(buffer, "int tmpInt%u;\n", i);
731 }
732
733 /* Temporary variables for matrix operations */
734 shader_addline(buffer, "vec4 tmp0;\n");
735 shader_addline(buffer, "vec4 tmp1;\n");
736
737 /* Local constants use a different name so they can be loaded once at shader link time
738 * They can't be hardcoded into the shader text via LC = {x, y, z, w}; because the
739 * float -> string conversion can cause precision loss.
740 */
741 if(!This->baseShader.load_local_constsF) {
742 LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
743 shader_addline(buffer, "uniform vec4 %cLC%u;\n", prefix, lconst->idx);
744 }
745 }
746
747 /* Start the main program */
748 shader_addline(buffer, "void main() {\n");
749 if(pshader && reg_maps->vpos) {
750 /* DirectX apps expect integer values, while OpenGL drivers add approximately 0.5. This causes
751 * off-by-one problems as spotted by the vPos d3d9 visual test. Unfortunately the ATI cards do
752 * not add exactly 0.5, but rather something like 0.49999999 or 0.50000001, which still causes
753 * precision troubles when we just substract 0.5.
754 *
755 * To deal with that just floor() the position. This will eliminate the fraction on all cards.
756 *
757 * TODO: Test how that behaves with multisampling once we can enable multisampling in winex11.
758 *
759 * An advantage of floor is that it works even if the driver doesn't add 1/2. It is somewhat
760 * questionable if 1.5, 2.5, ... are the proper values to return in gl_FragCoord, even though
761 * coordinates specify the pixel centers instead of the pixel corners. This code will behave
762 * correctly on drivers that returns integer values.
763 */
764 shader_addline(buffer, "vpos = floor(vec4(0, ycorrection[0], 0, 0) + gl_FragCoord * vec4(1, ycorrection[1], 1, 1));\n");
765 }
766 }
767
768 /*****************************************************************************
769 * Functions to generate GLSL strings from DirectX Shader bytecode begin here.
770 *
771 * For more information, see http://wiki.winehq.org/DirectX-Shaders
772 ****************************************************************************/
773
774 /* Prototypes */
775 static void shader_glsl_add_src_param(SHADER_OPCODE_ARG* arg, const DWORD param,
776 const DWORD addr_token, DWORD mask, glsl_src_param_t *src_param);
777
778 /** Used for opcode modifiers - They multiply the result by the specified amount */
779 static const char * const shift_glsl_tab[] = {
780 "", /* 0 (none) */
781 "2.0 * ", /* 1 (x2) */
782 "4.0 * ", /* 2 (x4) */
783 "8.0 * ", /* 3 (x8) */
784 "16.0 * ", /* 4 (x16) */
785 "32.0 * ", /* 5 (x32) */
786 "", /* 6 (x64) */
787 "", /* 7 (x128) */
788 "", /* 8 (d256) */
789 "", /* 9 (d128) */
790 "", /* 10 (d64) */
791 "", /* 11 (d32) */
792 "0.0625 * ", /* 12 (d16) */
793 "0.125 * ", /* 13 (d8) */
794 "0.25 * ", /* 14 (d4) */
795 "0.5 * " /* 15 (d2) */
796 };
797
798 /* Generate a GLSL parameter that does the input modifier computation and return the input register/mask to use */
799 static void shader_glsl_gen_modifier (
800 const DWORD instr,
801 const char *in_reg,
802 const char *in_regswizzle,
803 char *out_str) {
804
805 out_str[0] = 0;
806
807 if (instr == WINED3DSIO_TEXKILL)
808 return;
809
810 switch (instr & WINED3DSP_SRCMOD_MASK) {
811 case WINED3DSPSM_DZ: /* Need to handle this in the instructions itself (texld & texcrd). */
812 case WINED3DSPSM_DW:
813 case WINED3DSPSM_NONE:
814 sprintf(out_str, "%s%s", in_reg, in_regswizzle);
815 break;
816 case WINED3DSPSM_NEG:
817 sprintf(out_str, "-%s%s", in_reg, in_regswizzle);
818 break;
819 case WINED3DSPSM_NOT:
820 sprintf(out_str, "!%s%s", in_reg, in_regswizzle);
821 break;
822 case WINED3DSPSM_BIAS:
823 sprintf(out_str, "(%s%s - vec4(0.5)%s)", in_reg, in_regswizzle, in_regswizzle);
824 break;
825 case WINED3DSPSM_BIASNEG:
826 sprintf(out_str, "-(%s%s - vec4(0.5)%s)", in_reg, in_regswizzle, in_regswizzle);
827 break;
828 case WINED3DSPSM_SIGN:
829 sprintf(out_str, "(2.0 * (%s%s - 0.5))", in_reg, in_regswizzle);
830 break;
831 case WINED3DSPSM_SIGNNEG:
832 sprintf(out_str, "-(2.0 * (%s%s - 0.5))", in_reg, in_regswizzle);
833 break;
834 case WINED3DSPSM_COMP:
835 sprintf(out_str, "(1.0 - %s%s)", in_reg, in_regswizzle);
836 break;
837 case WINED3DSPSM_X2:
838 sprintf(out_str, "(2.0 * %s%s)", in_reg, in_regswizzle);
839 break;
840 case WINED3DSPSM_X2NEG:
841 sprintf(out_str, "-(2.0 * %s%s)", in_reg, in_regswizzle);
842 break;
843 case WINED3DSPSM_ABS:
844 sprintf(out_str, "abs(%s%s)", in_reg, in_regswizzle);
845 break;
846 case WINED3DSPSM_ABSNEG:
847 sprintf(out_str, "-abs(%s%s)", in_reg, in_regswizzle);
848 break;
849 default:
850 FIXME("Unhandled modifier %u\n", (instr & WINED3DSP_SRCMOD_MASK));
851 sprintf(out_str, "%s%s", in_reg, in_regswizzle);
852 }
853 }
854
855 /** Writes the GLSL variable name that corresponds to the register that the
856 * DX opcode parameter is trying to access */
857 static void shader_glsl_get_register_name(
858 const DWORD param,
859 const DWORD addr_token,
860 char* regstr,
861 BOOL* is_color,
862 SHADER_OPCODE_ARG* arg) {
863
864 /* oPos, oFog and oPts in D3D */
865 static const char * const hwrastout_reg_names[] = { "gl_Position", "gl_FogFragCoord", "gl_PointSize" };
866
867 DWORD reg = param & WINED3DSP_REGNUM_MASK;
868 DWORD regtype = shader_get_regtype(param);
869 IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) arg->shader;
870 IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
871 WineD3D_GL_Info* gl_info = &deviceImpl->adapter->gl_info;
872
873 char pshader = shader_is_pshader_version(This->baseShader.hex_version);
874 char tmpStr[150];
875
876 *is_color = FALSE;
877
878 switch (regtype) {
879 case WINED3DSPR_TEMP:
880 sprintf(tmpStr, "R%u", reg);
881 break;
882 case WINED3DSPR_INPUT:
883 if (pshader) {
884 /* Pixel shaders >= 3.0 */
885 if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 3) {
886 DWORD in_count = GL_LIMITS(glsl_varyings) / 4;
887
888 if (param & WINED3DSHADER_ADDRMODE_RELATIVE) {
889 glsl_src_param_t rel_param;
890 shader_glsl_add_src_param(arg, addr_token, 0, WINED3DSP_WRITEMASK_0, &rel_param);
891
892 /* Removing a + 0 would be an obvious optimization, but macos doesn't see the NOP
893 * operation there
894 */
895 if(((IWineD3DPixelShaderImpl *) This)->input_reg_map[reg]) {
896 if (((IWineD3DPixelShaderImpl *)This)->declared_in_count > in_count) {
897 sprintf(tmpStr, "((%s + %u) > %d ? (%s + %u) > %d ? gl_SecondaryColor : gl_Color : IN[%s + %u])",
898 rel_param.param_str, ((IWineD3DPixelShaderImpl *)This)->input_reg_map[reg], in_count - 1,
899 rel_param.param_str, ((IWineD3DPixelShaderImpl *)This)->input_reg_map[reg], in_count,
900 rel_param.param_str, ((IWineD3DPixelShaderImpl *)This)->input_reg_map[reg]);
901 } else {
902 sprintf(tmpStr, "IN[%s + %u]", rel_param.param_str, ((IWineD3DPixelShaderImpl *)This)->input_reg_map[reg]);
903 }
904 } else {
905 if (((IWineD3DPixelShaderImpl *)This)->declared_in_count > in_count) {
906 sprintf(tmpStr, "((%s) > %d ? (%s) > %d ? gl_SecondaryColor : gl_Color : IN[%s])",
907 rel_param.param_str, in_count - 1,
908 rel_param.param_str, in_count,
909 rel_param.param_str);
910 } else {
911 sprintf(tmpStr, "IN[%s]", rel_param.param_str);
912 }
913 }
914 } else {
915 DWORD idx = ((IWineD3DPixelShaderImpl *) This)->input_reg_map[reg];
916 if (idx == in_count) {
917 sprintf(tmpStr, "gl_Color");
918 } else if (idx == in_count + 1) {
919 sprintf(tmpStr, "gl_SecondaryColor");
920 } else {
921 sprintf(tmpStr, "IN[%u]", idx);
922 }
923 }
924 } else {
925 if (reg==0)
926 strcpy(tmpStr, "gl_Color");
927 else
928 strcpy(tmpStr, "gl_SecondaryColor");
929 }
930 } else {
931 if (vshader_input_is_color((IWineD3DVertexShader*) This, reg))
932 *is_color = TRUE;
933 sprintf(tmpStr, "attrib%u", reg);
934 }
935 break;
936 case WINED3DSPR_CONST:
937 {
938 const char prefix = pshader? 'P':'V';
939
940 /* Relative addressing */
941 if (param & WINED3DSHADER_ADDRMODE_RELATIVE) {
942
943 /* Relative addressing on shaders 2.0+ have a relative address token,
944 * prior to that, it was hard-coded as "A0.x" because there's only 1 register */
945 if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 2) {
946 glsl_src_param_t rel_param;
947 shader_glsl_add_src_param(arg, addr_token, 0, WINED3DSP_WRITEMASK_0, &rel_param);
948 if(reg) {
949 sprintf(tmpStr, "%cC[%s + %u]", prefix, rel_param.param_str, reg);
950 } else {
951 sprintf(tmpStr, "%cC[%s]", prefix, rel_param.param_str);
952 }
953 } else {
954 if(reg) {
955 sprintf(tmpStr, "%cC[A0.x + %u]", prefix, reg);
956 } else {
957 sprintf(tmpStr, "%cC[A0.x]", prefix);
958 }
959 }
960
961 } else {
962 if(shader_constant_is_local(This, reg)) {
963 sprintf(tmpStr, "%cLC%u", prefix, reg);
964 } else {
965 sprintf(tmpStr, "%cC[%u]", prefix, reg);
966 }
967 }
968
969 break;
970 }
971 case WINED3DSPR_CONSTINT:
972 if (pshader)
973 sprintf(tmpStr, "PI[%u]", reg);
974 else
975 sprintf(tmpStr, "VI[%u]", reg);
976 break;
977 case WINED3DSPR_CONSTBOOL:
978 if (pshader)
979 sprintf(tmpStr, "PB[%u]", reg);
980 else
981 sprintf(tmpStr, "VB[%u]", reg);
982 break;
983 case WINED3DSPR_TEXTURE: /* case WINED3DSPR_ADDR: */
984 if (pshader) {
985 sprintf(tmpStr, "T%u", reg);
986 } else {
987 sprintf(tmpStr, "A%u", reg);
988 }
989 break;
990 case WINED3DSPR_LOOP:
991 sprintf(tmpStr, "aL%u", This->baseShader.cur_loop_regno - 1);
992 break;
993 case WINED3DSPR_SAMPLER:
994 if (pshader)
995 sprintf(tmpStr, "Psampler%u", reg);
996 else
997 sprintf(tmpStr, "Vsampler%u", reg);
998 break;
999 case WINED3DSPR_COLOROUT:
1000 if (reg >= GL_LIMITS(buffers)) {
1001 WARN("Write to render target %u, only %d supported\n", reg, 4);
1002 }
1003 if (GL_SUPPORT(ARB_DRAW_BUFFERS)) {
1004 sprintf(tmpStr, "gl_FragData[%u]", reg);
1005 } else { /* On older cards with GLSL support like the GeforceFX there's only one buffer. */
1006 sprintf(tmpStr, "gl_FragColor");
1007 }
1008 break;
1009 case WINED3DSPR_RASTOUT:
1010 sprintf(tmpStr, "%s", hwrastout_reg_names[reg]);
1011 break;
1012 case WINED3DSPR_DEPTHOUT:
1013 sprintf(tmpStr, "gl_FragDepth");
1014 break;
1015 case WINED3DSPR_ATTROUT:
1016 if (reg == 0) {
1017 sprintf(tmpStr, "gl_FrontColor");
1018 } else {
1019 sprintf(tmpStr, "gl_FrontSecondaryColor");
1020 }
1021 break;
1022 case WINED3DSPR_TEXCRDOUT:
1023 /* Vertex shaders >= 3.0: WINED3DSPR_OUTPUT */
1024 if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 3)
1025 sprintf(tmpStr, "OUT[%u]", reg);
1026 else
1027 sprintf(tmpStr, "gl_TexCoord[%u]", reg);
1028 break;
1029 case WINED3DSPR_MISCTYPE:
1030 if (reg == 0) {
1031 /* vPos */
1032 sprintf(tmpStr, "vpos");
1033 } else if (reg == 1){
1034 /* Note that gl_FrontFacing is a bool, while vFace is
1035 * a float for which the sign determines front/back
1036 */
1037 sprintf(tmpStr, "(gl_FrontFacing ? 1.0 : -1.0)");
1038 } else {
1039 FIXME("Unhandled misctype register %d\n", reg);
1040 sprintf(tmpStr, "unrecognized_register");
1041 }
1042 break;
1043 default:
1044 FIXME("Unhandled register name Type(%d)\n", regtype);
1045 sprintf(tmpStr, "unrecognized_register");
1046 break;
1047 }
1048
1049 strcat(regstr, tmpStr);
1050 }
1051
1052 /* Get the GLSL write mask for the destination register */
1053 static DWORD shader_glsl_get_write_mask(const DWORD param, char *write_mask) {
1054 char *ptr = write_mask;
1055 DWORD mask = param & WINED3DSP_WRITEMASK_ALL;
1056
1057 if (shader_is_scalar(param)) {
1058 mask = WINED3DSP_WRITEMASK_0;
1059 } else {
1060 *ptr++ = '.';
1061 if (param & WINED3DSP_WRITEMASK_0) *ptr++ = 'x';
1062 if (param & WINED3DSP_WRITEMASK_1) *ptr++ = 'y';
1063 if (param & WINED3DSP_WRITEMASK_2) *ptr++ = 'z';
1064 if (param & WINED3DSP_WRITEMASK_3) *ptr++ = 'w';
1065 }
1066
1067 *ptr = '\0';
1068
1069 return mask;
1070 }
1071
1072 static unsigned int shader_glsl_get_write_mask_size(DWORD write_mask) {
1073 unsigned int size = 0;
1074
1075 if (write_mask & WINED3DSP_WRITEMASK_0) ++size;
1076 if (write_mask & WINED3DSP_WRITEMASK_1) ++size;
1077 if (write_mask & WINED3DSP_WRITEMASK_2) ++size;
1078 if (write_mask & WINED3DSP_WRITEMASK_3) ++size;
1079
1080 return size;
1081 }
1082
1083 static void shader_glsl_get_swizzle(const DWORD param, BOOL fixup, DWORD mask, char *swizzle_str) {
1084 /* For registers of type WINED3DDECLTYPE_D3DCOLOR, data is stored as "bgra",
1085 * but addressed as "rgba". To fix this we need to swap the register's x
1086 * and z components. */
1087 DWORD swizzle = (param & WINED3DSP_SWIZZLE_MASK) >> WINED3DSP_SWIZZLE_SHIFT;
1088 const char *swizzle_chars = fixup ? "zyxw" : "xyzw";
1089 char *ptr = swizzle_str;
1090
1091 if (!shader_is_scalar(param)) {
1092 *ptr++ = '.';
1093 /* swizzle bits fields: wwzzyyxx */
1094 if (mask & WINED3DSP_WRITEMASK_0) *ptr++ = swizzle_chars[swizzle & 0x03];
1095 if (mask & WINED3DSP_WRITEMASK_1) *ptr++ = swizzle_chars[(swizzle >> 2) & 0x03];
1096 if (mask & WINED3DSP_WRITEMASK_2) *ptr++ = swizzle_chars[(swizzle >> 4) & 0x03];
1097 if (mask & WINED3DSP_WRITEMASK_3) *ptr++ = swizzle_chars[(swizzle >> 6) & 0x03];
1098 }
1099
1100 *ptr = '\0';
1101 }
1102
1103 /* From a given parameter token, generate the corresponding GLSL string.
1104 * Also, return the actual register name and swizzle in case the
1105 * caller needs this information as well. */
1106 static void shader_glsl_add_src_param(SHADER_OPCODE_ARG* arg, const DWORD param,
1107 const DWORD addr_token, DWORD mask, glsl_src_param_t *src_param) {
1108 BOOL is_color = FALSE;
1109 char swizzle_str[6];
1110
1111 src_param->reg_name[0] = '\0';
1112 src_param->param_str[0] = '\0';
1113 swizzle_str[0] = '\0';
1114
1115 shader_glsl_get_register_name(param, addr_token, src_param->reg_name, &is_color, arg);
1116
1117 shader_glsl_get_swizzle(param, is_color, mask, swizzle_str);
1118 shader_glsl_gen_modifier(param, src_param->reg_name, swizzle_str, src_param->param_str);
1119 }
1120
1121 /* From a given parameter token, generate the corresponding GLSL string.
1122 * Also, return the actual register name and swizzle in case the
1123 * caller needs this information as well. */
1124 static DWORD shader_glsl_add_dst_param(SHADER_OPCODE_ARG* arg, const DWORD param,
1125 const DWORD addr_token, glsl_dst_param_t *dst_param) {
1126 BOOL is_color = FALSE;
1127
1128 dst_param->mask_str[0] = '\0';
1129 dst_param->reg_name[0] = '\0';
1130
1131 shader_glsl_get_register_name(param, addr_token, dst_param->reg_name, &is_color, arg);
1132 return shader_glsl_get_write_mask(param, dst_param->mask_str);
1133 }
1134
1135 /* Append the destination part of the instruction to the buffer, return the effective write mask */
1136 static DWORD shader_glsl_append_dst_ext(SHADER_BUFFER *buffer, SHADER_OPCODE_ARG *arg, const DWORD param) {
1137 glsl_dst_param_t dst_param;
1138 DWORD mask;
1139 int shift;
1140
1141 mask = shader_glsl_add_dst_param(arg, param, arg->dst_addr, &dst_param);
1142
1143 if(mask) {
1144 shift = (param & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
1145 shader_addline(buffer, "%s%s = %s(", dst_param.reg_name, dst_param.mask_str, shift_glsl_tab[shift]);
1146 }
1147
1148 return mask;
1149 }
1150
1151 /* Append the destination part of the instruction to the buffer, return the effective write mask */
1152 static DWORD shader_glsl_append_dst(SHADER_BUFFER *buffer, SHADER_OPCODE_ARG *arg) {
1153 return shader_glsl_append_dst_ext(buffer, arg, arg->dst);
1154 }
1155
1156 /** Process GLSL instruction modifiers */
1157 void shader_glsl_add_instruction_modifiers(SHADER_OPCODE_ARG* arg) {
1158
1159 DWORD mask = arg->dst & WINED3DSP_DSTMOD_MASK;
1160
1161 if (arg->opcode->dst_token && mask != 0) {
1162 glsl_dst_param_t dst_param;
1163
1164 shader_glsl_add_dst_param(arg, arg->dst, 0, &dst_param);
1165
1166 if (mask & WINED3DSPDM_SATURATE) {
1167 /* _SAT means to clamp the value of the register to between 0 and 1 */
1168 shader_addline(arg->buffer, "%s%s = clamp(%s%s, 0.0, 1.0);\n", dst_param.reg_name,
1169 dst_param.mask_str, dst_param.reg_name, dst_param.mask_str);
1170 }
1171 if (mask & WINED3DSPDM_MSAMPCENTROID) {
1172 FIXME("_centroid modifier not handled\n");
1173 }
1174 if (mask & WINED3DSPDM_PARTIALPRECISION) {
1175 /* MSDN says this modifier can be safely ignored, so that's what we'll do. */
1176 }
1177 }
1178 }
1179
1180 static inline const char* shader_get_comp_op(
1181 const DWORD opcode) {
1182
1183 DWORD op = (opcode & INST_CONTROLS_MASK) >> INST_CONTROLS_SHIFT;
1184 switch (op) {
1185 case COMPARISON_GT: return ">";
1186 case COMPARISON_EQ: return "==";
1187 case COMPARISON_GE: return ">=";
1188 case COMPARISON_LT: return "<";
1189 case COMPARISON_NE: return "!=";
1190 case COMPARISON_LE: return "<=";
1191 default:
1192 FIXME("Unrecognized comparison value: %u\n", op);
1193 return "(\?\?)";
1194 }
1195 }
1196
1197 static void shader_glsl_get_sample_function(DWORD sampler_type, BOOL projected, BOOL texrect, glsl_sample_function_t *sample_function) {
1198 /* Note that there's no such thing as a projected cube texture. */
1199 switch(sampler_type) {
1200 case WINED3DSTT_1D:
1201 sample_function->name = projected ? "texture1DProj" : "texture1D";
1202 sample_function->coord_mask = WINED3DSP_WRITEMASK_0;
1203 break;
1204 case WINED3DSTT_2D:
1205 if(texrect) {
1206 sample_function->name = projected ? "texture2DRectProj" : "texture2DRect";
1207 } else {
1208 sample_function->name = projected ? "texture2DProj" : "texture2D";
1209 }
1210 sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1;
1211 break;
1212 case WINED3DSTT_CUBE:
1213 sample_function->name = "textureCube";
1214 sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
1215 break;
1216 case WINED3DSTT_VOLUME:
1217 sample_function->name = projected ? "texture3DProj" : "texture3D";
1218 sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
1219 break;
1220 default:
1221 sample_function->name = "";
1222 FIXME("Unrecognized sampler type: %#x;\n", sampler_type);
1223 break;
1224 }
1225 }
1226
1227 static void shader_glsl_color_correction(SHADER_OPCODE_ARG* arg) {
1228 IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
1229 IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) shader->baseShader.device;
1230 WineD3D_GL_Info *gl_info = &deviceImpl->adapter->gl_info;
1231 glsl_dst_param_t dst_param;
1232 glsl_dst_param_t dst_param2;
1233 WINED3DFORMAT fmt;
1234 WINED3DFORMAT conversion_group;
1235 IWineD3DBaseTextureImpl *texture;
1236 DWORD mask, mask_size;
1237 UINT i;
1238 BOOL recorded = FALSE;
1239 DWORD sampler_idx;
1240 DWORD hex_version = shader->baseShader.hex_version;
1241
1242 switch(arg->opcode->opcode) {
1243 case WINED3DSIO_TEX:
1244 if (hex_version < WINED3DPS_VERSION(2,0)) {
1245 sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
1246 } else {
1247 sampler_idx = arg->src[1] & WINED3DSP_REGNUM_MASK;
1248 }
1249 break;
1250
1251 case WINED3DSIO_TEXLDL:
1252 FIXME("Add color fixup for vertex texture WINED3DSIO_TEXLDL\n");
1253 return;
1254
1255 case WINED3DSIO_TEXDP3TEX:
1256 case WINED3DSIO_TEXM3x3TEX:
1257 case WINED3DSIO_TEXM3x3SPEC:
1258 case WINED3DSIO_TEXM3x3VSPEC:
1259 case WINED3DSIO_TEXBEM:
1260 case WINED3DSIO_TEXREG2AR:
1261 case WINED3DSIO_TEXREG2GB:
1262 case WINED3DSIO_TEXREG2RGB:
1263 sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
1264 break;
1265
1266 default:
1267 /* Not a texture sampling instruction, nothing to do */
1268 return;
1269 };
1270
1271 texture = (IWineD3DBaseTextureImpl *) deviceImpl->stateBlock->textures[sampler_idx];
1272 if(texture) {
1273 fmt = texture->resource.format;
1274 conversion_group = texture->baseTexture.shader_conversion_group;
1275 } else {
1276 fmt = WINED3DFMT_UNKNOWN;
1277 conversion_group = WINED3DFMT_UNKNOWN;
1278 }
1279
1280 /* before doing anything, record the sampler with the format in the format conversion list,
1281 * but check if it's not there already
1282 */
1283 for(i = 0; i < shader->baseShader.num_sampled_samplers; i++) {
1284 if(shader->baseShader.sampled_samplers[i] == sampler_idx) {
1285 recorded = TRUE;
1286 break;
1287 }
1288 }
1289 if(!recorded) {
1290 shader->baseShader.sampled_samplers[shader->baseShader.num_sampled_samplers] = sampler_idx;
1291 shader->baseShader.num_sampled_samplers++;
1292 shader->baseShader.sampled_format[sampler_idx] = conversion_group;
1293 }
1294
1295 switch(fmt) {
1296 case WINED3DFMT_V8U8:
1297 case WINED3DFMT_V16U16:
1298 if(GL_SUPPORT(NV_TEXTURE_SHADER) ||
1299 (GL_SUPPORT(ATI_ENVMAP_BUMPMAP) && fmt == WINED3DFMT_V8U8)) {
1300 /* The 3rd channel returns 1.0 in d3d, but 0.0 in gl. Fix this while we're at it :-) */
1301 mask = shader_glsl_add_dst_param(arg, arg->dst, WINED3DSP_WRITEMASK_2, &dst_param);
1302 mask_size = shader_glsl_get_write_mask_size(mask);
1303 if(mask_size >= 3) {
1304 shader_addline(arg->buffer, "%s.%c = 1.0;\n", dst_param.reg_name, dst_param.mask_str[3]);
1305 }
1306 } else {
1307 /* Correct the sign, but leave the blue as it is - it was loaded correctly already */
1308 mask = shader_glsl_add_dst_param(arg, arg->dst,
1309 WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1,
1310 &dst_param);
1311 mask_size = shader_glsl_get_write_mask_size(mask);
1312 if(mask_size >= 2) {
1313 shader_addline(arg->buffer, "%s.%c%c = %s.%c%c * 2.0 - 1.0;\n",
1314 dst_param.reg_name, dst_param.mask_str[1], dst_param.mask_str[2],
1315 dst_param.reg_name, dst_param.mask_str[1], dst_param.mask_str[2]);
1316 } else if(mask_size == 1) {
1317 shader_addline(arg->buffer, "%s.%c = %s.%c * 2.0 - 1.0;\n", dst_param.reg_name, dst_param.mask_str[1],
1318 dst_param.reg_name, dst_param.mask_str[1]);
1319 }
1320 }
1321 break;
1322
1323 case WINED3DFMT_X8L8V8U8:
1324 if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
1325 /* Red and blue are the signed channels, fix them up; Blue(=L) is correct already,
1326 * and a(X) is always 1.0
1327 */
1328 mask = shader_glsl_add_dst_param(arg, arg->dst, WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &dst_param);
1329 mask_size = shader_glsl_get_write_mask_size(mask);
1330 if(mask_size >= 2) {
1331 shader_addline(arg->buffer, "%s.%c%c = %s.%c%c * 2.0 - 1.0;\n",
1332 dst_param.reg_name, dst_param.mask_str[1], dst_param.mask_str[2],
1333 dst_param.reg_name, dst_param.mask_str[1], dst_param.mask_str[2]);
1334 } else if(mask_size == 1) {
1335 shader_addline(arg->buffer, "%s.%c = %s.%c * 2.0 - 1.0;\n",
1336 dst_param.reg_name, dst_param.mask_str[1],
1337 dst_param.reg_name, dst_param.mask_str[1]);
1338 }
1339 }
1340 break;
1341
1342 case WINED3DFMT_L6V5U5:
1343 if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
1344 mask = shader_glsl_add_dst_param(arg, arg->dst, WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &dst_param);
1345 mask_size = shader_glsl_get_write_mask_size(mask);
1346 shader_glsl_add_dst_param(arg, arg->dst, WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_2, &dst_param2);
1347 if(mask_size >= 3) {
1348 /* Swap y and z (U and L), and do a sign conversion on x and the new y(V and U) */
1349 shader_addline(arg->buffer, "tmp0.g = %s.%c;\n",
1350 dst_param.reg_name, dst_param.mask_str[2]);
1351 shader_addline(arg->buffer, "%s.%c%c = %s.%c%c * 2.0 - 1.0;\n",
1352 dst_param.reg_name, dst_param.mask_str[2], dst_param.mask_str[1],
1353 dst_param2.reg_name, dst_param.mask_str[1], dst_param.mask_str[3]);
1354 shader_addline(arg->buffer, "%s.%c = tmp0.g;\n", dst_param.reg_name,
1355 dst_param.mask_str[3]);
1356 } else if(mask_size == 2) {
1357 /* This is bad: We have VL, but we need VU */
1358 FIXME("2 components sampled from a converted L6V5U5 texture\n");
1359 } else {
1360 shader_addline(arg->buffer, "%s.%c = %s.%c * 2.0 - 1.0;\n",
1361 dst_param.reg_name, dst_param.mask_str[1],
1362 dst_param2.reg_name, dst_param.mask_str[1]);
1363 }
1364 }
1365 break;
1366
1367 case WINED3DFMT_Q8W8V8U8:
1368 if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
1369 /* Correct the sign in all channels. The writemask just applies as-is, no
1370 * need for checking the mask size
1371 */
1372 shader_glsl_add_dst_param(arg, arg->dst,
1373 WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 |
1374 WINED3DSP_WRITEMASK_2 | WINED3DSP_WRITEMASK_3,
1375 &dst_param);
1376 shader_addline(arg->buffer, "%s%s = %s%s * 2.0 - 1.0;\n", dst_param.reg_name, dst_param.mask_str,
1377 dst_param.reg_name, dst_param.mask_str);
1378 }
1379 break;
1380
1381 case WINED3DFMT_ATI2N:
1382 /* GL_ATI_texture_compression_3dc returns the two channels as luminance-alpha,
1383 * which means the first one is replicated across .rgb, and the 2nd one is in
1384 * .a. We need the 2nd in .g
1385 *
1386 * GL_EXT_texture_compression_rgtc returns the values in .rg, however, they
1387 * are swapped compared to d3d. So swap red and green.
1388 */
1389 mask = shader_glsl_add_dst_param(arg, arg->dst, WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &dst_param);
1390 mask_size = shader_glsl_get_write_mask_size(mask);
1391 if(GL_SUPPORT(EXT_TEXTURE_COMPRESSION_RGTC)) {
1392 if(mask_size >= 2) {
1393 shader_addline(arg->buffer, "%s.%c%c = %s.%c%c;\n",
1394 dst_param.reg_name, dst_param.mask_str[1],
1395 dst_param.mask_str[2],
1396 dst_param.reg_name, dst_param.mask_str[2],
1397 dst_param.mask_str[1]);
1398 } else {
1399 FIXME("%u components sampled from a converted ATI2N texture\n", mask_size);
1400 }
1401 } else {
1402 if(mask_size == 4) {
1403 /* Swap y and z (U and L), and do a sign conversion on x and the new y(V and U) */
1404 shader_addline(arg->buffer, "%s.%c = %s.%c;\n",
1405 dst_param.reg_name, dst_param.mask_str[2],
1406 dst_param.reg_name, dst_param.mask_str[4]);
1407 } else if(mask_size == 1) {
1408 /* Nothing to do */
1409 } else {
1410 FIXME("%u components sampled from a converted ATI2N texture\n", mask_size);
1411 /* This is bad: We have .r[gb], but we need .ra */
1412 }
1413 }
1414 break;
1415
1416 /* stupid compiler */
1417 default:
1418 break;
1419 }
1420 }
1421
1422 /*****************************************************************************
1423 *
1424 * Begin processing individual instruction opcodes
1425 *
1426 ****************************************************************************/
1427
1428 /* Generate GLSL arithmetic functions (dst = src1 + src2) */
1429 void shader_glsl_arith(SHADER_OPCODE_ARG* arg) {
1430 CONST SHADER_OPCODE* curOpcode = arg->opcode;
1431 SHADER_BUFFER* buffer = arg->buffer;
1432 glsl_src_param_t src0_param;
1433 glsl_src_param_t src1_param;
1434 DWORD write_mask;
1435 char op;
1436
1437 /* Determine the GLSL operator to use based on the opcode */
1438 switch (curOpcode->opcode) {
1439 case WINED3DSIO_MUL: op = '*'; break;
1440 case WINED3DSIO_ADD: op = '+'; break;
1441 case WINED3DSIO_SUB: op = '-'; break;
1442 default:
1443 op = ' ';
1444 FIXME("Opcode %s not yet handled in GLSL\n", curOpcode->name);
1445 break;
1446 }
1447
1448 write_mask = shader_glsl_append_dst(buffer, arg);
1449 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
1450 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
1451 shader_addline(buffer, "%s %c %s);\n", src0_param.param_str, op, src1_param.param_str);
1452 }
1453
1454 /* Process the WINED3DSIO_MOV opcode using GLSL (dst = src) */
1455 void shader_glsl_mov(SHADER_OPCODE_ARG* arg) {
1456 IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
1457 SHADER_BUFFER* buffer = arg->buffer;
1458 glsl_src_param_t src0_param;
1459 DWORD write_mask;
1460
1461 write_mask = shader_glsl_append_dst(buffer, arg);
1462 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
1463
1464 /* In vs_1_1 WINED3DSIO_MOV can write to the address register. In later
1465 * shader versions WINED3DSIO_MOVA is used for this. */
1466 if ((WINED3DSHADER_VERSION_MAJOR(shader->baseShader.hex_version) == 1 &&
1467 !shader_is_pshader_version(shader->baseShader.hex_version) &&
1468 shader_get_regtype(arg->dst) == WINED3DSPR_ADDR)) {
1469 /* This is a simple floor() */
1470 unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
1471 if (mask_size > 1) {
1472 shader_addline(buffer, "ivec%d(floor(%s)));\n", mask_size, src0_param.param_str);
1473 } else {
1474 shader_addline(buffer, "int(floor(%s)));\n", src0_param.param_str);
1475 }
1476 } else if(arg->opcode->opcode == WINED3DSIO_MOVA) {
1477 /* We need to *round* to the nearest int here. */
1478 unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
1479 if (mask_size > 1) {
1480 shader_addline(buffer, "ivec%d(floor(abs(%s) + vec%d(0.5)) * sign(%s)));\n", mask_size, src0_param.param_str, mask_size, src0_param.param_str);
1481 } else {
1482 shader_addline(buffer, "int(floor(abs(%s) + 0.5) * sign(%s)));\n", src0_param.param_str, src0_param.param_str);
1483 }
1484 } else {
1485 shader_addline(buffer, "%s);\n", src0_param.param_str);
1486 }
1487 }
1488
1489 /* Process the dot product operators DP3 and DP4 in GLSL (dst = dot(src0, src1)) */
1490 void shader_glsl_dot(SHADER_OPCODE_ARG* arg) {
1491 CONST SHADER_OPCODE* curOpcode = arg->opcode;
1492 SHADER_BUFFER* buffer = arg->buffer;
1493 glsl_src_param_t src0_param;
1494 glsl_src_param_t src1_param;
1495 DWORD dst_write_mask, src_write_mask;
1496 unsigned int dst_size = 0;
1497
1498 dst_write_mask = shader_glsl_append_dst(buffer, arg);
1499 dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
1500
1501 /* dp3 works on vec3, dp4 on vec4 */
1502 if (curOpcode->opcode == WINED3DSIO_DP4) {
1503 src_write_mask = WINED3DSP_WRITEMASK_ALL;
1504 } else {
1505 src_write_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
1506 }
1507
1508 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_write_mask, &src0_param);
1509 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], src_write_mask, &src1_param);
1510
1511 if (dst_size > 1) {
1512 shader_addline(buffer, "vec%d(dot(%s, %s)));\n", dst_size, src0_param.param_str, src1_param.param_str);
1513 } else {
1514 shader_addline(buffer, "dot(%s, %s));\n", src0_param.param_str, src1_param.param_str);
1515 }
1516 }
1517
1518 /* Note that this instruction has some restrictions. The destination write mask
1519 * can't contain the w component, and the source swizzles have to be .xyzw */
1520 void shader_glsl_cross(SHADER_OPCODE_ARG *arg) {
1521 DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
1522 glsl_src_param_t src0_param;
1523 glsl_src_param_t src1_param;
1524 char dst_mask[6];
1525
1526 shader_glsl_get_write_mask(arg->dst, dst_mask);
1527 shader_glsl_append_dst(arg->buffer, arg);
1528 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
1529 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], src_mask, &src1_param);
1530 shader_addline(arg->buffer, "cross(%s, %s)%s);\n", src0_param.param_str, src1_param.param_str, dst_mask);
1531 }
1532
1533 /* Process the WINED3DSIO_POW instruction in GLSL (dst = |src0|^src1)
1534 * Src0 and src1 are scalars. Note that D3D uses the absolute of src0, while
1535 * GLSL uses the value as-is. */
1536 void shader_glsl_pow(SHADER_OPCODE_ARG *arg) {
1537 SHADER_BUFFER *buffer = arg->buffer;
1538 glsl_src_param_t src0_param;
1539 glsl_src_param_t src1_param;
1540 DWORD dst_write_mask;
1541 unsigned int dst_size;
1542
1543 dst_write_mask = shader_glsl_append_dst(buffer, arg);
1544 dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
1545
1546 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
1547 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
1548
1549 if (dst_size > 1) {
1550 shader_addline(buffer, "vec%d(pow(abs(%s), %s)));\n", dst_size, src0_param.param_str, src1_param.param_str);
1551 } else {
1552 shader_addline(buffer, "pow(abs(%s), %s));\n", src0_param.param_str, src1_param.param_str);
1553 }
1554 }
1555
1556 /* Process the WINED3DSIO_LOG instruction in GLSL (dst = log2(|src0|))
1557 * Src0 is a scalar. Note that D3D uses the absolute of src0, while
1558 * GLSL uses the value as-is. */
1559 void shader_glsl_log(SHADER_OPCODE_ARG *arg) {
1560 SHADER_BUFFER *buffer = arg->buffer;
1561 glsl_src_param_t src0_param;
1562 DWORD dst_write_mask;
1563 unsigned int dst_size;
1564
1565 dst_write_mask = shader_glsl_append_dst(buffer, arg);
1566 dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
1567
1568 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
1569
1570 if (dst_size > 1) {
1571 shader_addline(buffer, "vec%d(log2(abs(%s))));\n", dst_size, src0_param.param_str);
1572 } else {
1573 shader_addline(buffer, "log2(abs(%s)));\n", src0_param.param_str);
1574 }
1575 }
1576
1577 /* Map the opcode 1-to-1 to the GL code (arg->dst = instruction(src0, src1, ...) */
1578 void shader_glsl_map2gl(SHADER_OPCODE_ARG* arg) {
1579 CONST SHADER_OPCODE* curOpcode = arg->opcode;
1580 SHADER_BUFFER* buffer = arg->buffer;
1581 glsl_src_param_t src_param;
1582 const char *instruction;
1583 char arguments[256];
1584 DWORD write_mask;
1585 unsigned i;
1586
1587 /* Determine the GLSL function to use based on the opcode */
1588 /* TODO: Possibly make this a table for faster lookups */
1589 switch (curOpcode->opcode) {
1590 case WINED3DSIO_MIN: instruction = "min"; break;
1591 case WINED3DSIO_MAX: instruction = "max"; break;
1592 case WINED3DSIO_ABS: instruction = "abs"; break;
1593 case WINED3DSIO_FRC: instruction = "fract"; break;
1594 case WINED3DSIO_NRM: instruction = "normalize"; break;
1595 case WINED3DSIO_EXP: instruction = "exp2"; break;
1596 case WINED3DSIO_SGN: instruction = "sign"; break;
1597 case WINED3DSIO_DSX: instruction = "dFdx"; break;
1598 case WINED3DSIO_DSY: instruction = "ycorrection.y * dFdy"; break;
1599 default: instruction = "";
1600 FIXME("Opcode %s not yet handled in GLSL\n", curOpcode->name);
1601 break;
1602 }
1603
1604 write_mask = shader_glsl_append_dst(buffer, arg);
1605
1606 arguments[0] = '\0';
1607 if (curOpcode->num_params > 0) {
1608 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src_param);
1609 strcat(arguments, src_param.param_str);
1610 for (i = 2; i < curOpcode->num_params; ++i) {
1611 strcat(arguments, ", ");
1612 shader_glsl_add_src_param(arg, arg->src[i-1], arg->src_addr[i-1], write_mask, &src_param);
1613 strcat(arguments, src_param.param_str);
1614 }
1615 }
1616
1617 shader_addline(buffer, "%s(%s));\n", instruction, arguments);
1618 }
1619
1620 /** Process the WINED3DSIO_EXPP instruction in GLSL:
1621 * For shader model 1.x, do the following (and honor the writemask, so use a temporary variable):
1622 * dst.x = 2^(floor(src))
1623 * dst.y = src - floor(src)
1624 * dst.z = 2^src (partial precision is allowed, but optional)
1625 * dst.w = 1.0;
1626 * For 2.0 shaders, just do this (honoring writemask and swizzle):
1627 * dst = 2^src; (partial precision is allowed, but optional)
1628 */
1629 void shader_glsl_expp(SHADER_OPCODE_ARG* arg) {
1630 IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)arg->shader;
1631 glsl_src_param_t src_param;
1632
1633 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src_param);
1634
1635 if (shader->baseShader.hex_version < WINED3DPS_VERSION(2,0)) {
1636 char dst_mask[6];
1637
1638 shader_addline(arg->buffer, "tmp0.x = exp2(floor(%s));\n", src_param.param_str);
1639 shader_addline(arg->buffer, "tmp0.y = %s - floor(%s);\n", src_param.param_str, src_param.param_str);
1640 shader_addline(arg->buffer, "tmp0.z = exp2(%s);\n", src_param.param_str);
1641 shader_addline(arg->buffer, "tmp0.w = 1.0;\n");
1642
1643 shader_glsl_append_dst(arg->buffer, arg);
1644 shader_glsl_get_write_mask(arg->dst, dst_mask);
1645 shader_addline(arg->buffer, "tmp0%s);\n", dst_mask);
1646 } else {
1647 DWORD write_mask;
1648 unsigned int mask_size;
1649
1650 write_mask = shader_glsl_append_dst(arg->buffer, arg);
1651 mask_size = shader_glsl_get_write_mask_size(write_mask);
1652
1653 if (mask_size > 1) {
1654 shader_addline(arg->buffer, "vec%d(exp2(%s)));\n", mask_size, src_param.param_str);
1655 } else {
1656 shader_addline(arg->buffer, "exp2(%s));\n", src_param.param_str);
1657 }
1658 }
1659 }
1660
1661 /** Process the RCP (reciprocal or inverse) opcode in GLSL (dst = 1 / src) */
1662 void shader_glsl_rcp(SHADER_OPCODE_ARG* arg) {
1663 glsl_src_param_t src_param;
1664 DWORD write_mask;
1665 unsigned int mask_size;
1666
1667 write_mask = shader_glsl_append_dst(arg->buffer, arg);
1668 mask_size = shader_glsl_get_write_mask_size(write_mask);
1669 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &src_param);
1670
1671 if (mask_size > 1) {
1672 shader_addline(arg->buffer, "vec%d(1.0 / %s));\n", mask_size, src_param.param_str);
1673 } else {
1674 shader_addline(arg->buffer, "1.0 / %s);\n", src_param.param_str);
1675 }
1676 }
1677
1678 void shader_glsl_rsq(SHADER_OPCODE_ARG* arg) {
1679 SHADER_BUFFER* buffer = arg->buffer;
1680 glsl_src_param_t src_param;
1681 DWORD write_mask;
1682 unsigned int mask_size;
1683
1684 write_mask = shader_glsl_append_dst(buffer, arg);
1685 mask_size = shader_glsl_get_write_mask_size(write_mask);
1686
1687 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &src_param);
1688
1689 if (mask_size > 1) {
1690 shader_addline(buffer, "vec%d(inversesqrt(%s)));\n", mask_size, src_param.param_str);
1691 } else {
1692 shader_addline(buffer, "inversesqrt(%s));\n", src_param.param_str);
1693 }
1694 }
1695
1696 /** Process signed comparison opcodes in GLSL. */
1697 void shader_glsl_compare(SHADER_OPCODE_ARG* arg) {
1698 glsl_src_param_t src0_param;
1699 glsl_src_param_t src1_param;
1700 DWORD write_mask;
1701 unsigned int mask_size;
1702
1703 write_mask = shader_glsl_append_dst(arg->buffer, arg);
1704 mask_size = shader_glsl_get_write_mask_size(write_mask);
1705 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
1706 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
1707
1708 if (mask_size > 1) {
1709 const char *compare;
1710
1711 switch(arg->opcode->opcode) {
1712 case WINED3DSIO_SLT: compare = "lessThan"; break;
1713 case WINED3DSIO_SGE: compare = "greaterThanEqual"; break;
1714 default: compare = "";
1715 FIXME("Can't handle opcode %s\n", arg->opcode->name);
1716 }
1717
1718 shader_addline(arg->buffer, "vec%d(%s(%s, %s)));\n", mask_size, compare,
1719 src0_param.param_str, src1_param.param_str);
1720 } else {
1721 switch(arg->opcode->opcode) {
1722 case WINED3DSIO_SLT:
1723 /* Step(src0, src1) is not suitable here because if src0 == src1 SLT is supposed,
1724 * to return 0.0 but step returns 1.0 because step is not < x
1725 * An alternative is a bvec compare padded with an unused second component.
1726 * step(src1 * -1.0, src0 * -1.0) is not an option because it suffers from the same
1727 * issue. Playing with not() is not possible either because not() does not accept
1728 * a scalar.
1729 */
1730 shader_addline(arg->buffer, "(%s < %s) ? 1.0 : 0.0);\n", src0_param.param_str, src1_param.param_str);
1731 break;
1732 case WINED3DSIO_SGE:
1733 /* Here we can use the step() function and safe a conditional */
1734 shader_addline(arg->buffer, "step(%s, %s));\n", src1_param.param_str, src0_param.param_str);
1735 break;
1736 default:
1737 FIXME("Can't handle opcode %s\n", arg->opcode->name);
1738 }
1739
1740 }
1741 }
1742
1743 /** Process CMP instruction in GLSL (dst = src0 >= 0.0 ? src1 : src2), per channel */
1744 void shader_glsl_cmp(SHADER_OPCODE_ARG* arg) {
1745 glsl_src_param_t src0_param;
1746 glsl_src_param_t src1_param;
1747 glsl_src_param_t src2_param;
1748 DWORD write_mask, cmp_channel = 0;
1749 unsigned int i, j;
1750 char mask_char[6];
1751 BOOL temp_destination = FALSE;
1752
1753 if(shader_is_scalar(arg->src[0])) {
1754 write_mask = shader_glsl_append_dst(arg->buffer, arg);
1755
1756 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
1757 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
1758 shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
1759
1760 shader_addline(arg->buffer, "%s >= 0.0 ? %s : %s);\n",
1761 src0_param.param_str, src1_param.param_str, src2_param.param_str);
1762 } else {
1763 DWORD src0reg = arg->src[0] & WINED3DSP_REGNUM_MASK;
1764 DWORD src1reg = arg->src[1] & WINED3DSP_REGNUM_MASK;
1765 DWORD src2reg = arg->src[2] & WINED3DSP_REGNUM_MASK;
1766 DWORD src0regtype = shader_get_regtype(arg->src[0]);
1767 DWORD src1regtype = shader_get_regtype(arg->src[1]);
1768 DWORD src2regtype = shader_get_regtype(arg->src[2]);
1769 DWORD dstreg = arg->dst & WINED3DSP_REGNUM_MASK;
1770 DWORD dstregtype = shader_get_regtype(arg->dst);
1771
1772 /* Cycle through all source0 channels */
1773 for (i=0; i<4; i++) {
1774 write_mask = 0;
1775 /* Find the destination channels which use the current source0 channel */
1776 for (j=0; j<4; j++) {
1777 if ( ((arg->src[0] >> (WINED3DSP_SWIZZLE_SHIFT + 2*j)) & 0x3) == i ) {
1778 write_mask |= WINED3DSP_WRITEMASK_0 << j;
1779 cmp_channel = WINED3DSP_WRITEMASK_0 << j;
1780 }
1781 }
1782
1783 /* Splitting the cmp instruction up in multiple lines imposes a problem:
1784 * The first lines may overwrite source parameters of the following lines.
1785 * Deal with that by using a temporary destination register if needed
1786 */
1787 if((src0reg == dstreg && src0regtype == dstregtype) ||
1788 (src1reg == dstreg && src1regtype == dstregtype) ||
1789 (src2reg == dstreg && src2regtype == dstregtype)) {
1790
1791 write_mask = shader_glsl_get_write_mask(arg->dst & (~WINED3DSP_SWIZZLE_MASK | write_mask), mask_char);
1792 if (!write_mask) continue;
1793 shader_addline(arg->buffer, "tmp0%s = (", mask_char);
1794 temp_destination = TRUE;
1795 } else {
1796 write_mask = shader_glsl_append_dst_ext(arg->buffer, arg, arg->dst & (~WINED3DSP_SWIZZLE_MASK | write_mask));
1797 if (!write_mask) continue;
1798 }
1799
1800 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], cmp_channel, &src0_param);
1801 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
1802 shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
1803
1804 shader_addline(arg->buffer, "%s >= 0.0 ? %s : %s);\n",
1805 src0_param.param_str, src1_param.param_str, src2_param.param_str);
1806 }
1807
1808 if(temp_destination) {
1809 shader_glsl_get_write_mask(arg->dst, mask_char);
1810 shader_glsl_append_dst_ext(arg->buffer, arg, arg->dst);
1811 shader_addline(arg->buffer, "tmp0%s);\n", mask_char);
1812 }
1813 }
1814
1815 }
1816
1817 /** Process the CND opcode in GLSL (dst = (src0 > 0.5) ? src1 : src2) */
1818 /* For ps 1.1-1.3, only a single component of src0 is used. For ps 1.4
1819 * the compare is done per component of src0. */
1820 void shader_glsl_cnd(SHADER_OPCODE_ARG* arg) {
1821 IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
1822 glsl_src_param_t src0_param;
1823 glsl_src_param_t src1_param;
1824 glsl_src_param_t src2_param;
1825 DWORD write_mask, cmp_channel = 0;
1826 unsigned int i, j;
1827
1828 if (shader->baseShader.hex_version < WINED3DPS_VERSION(1, 4)) {
1829 write_mask = shader_glsl_append_dst(arg->buffer, arg);
1830 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
1831 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
1832 shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
1833
1834 /* Fun: The D3DSI_COISSUE flag changes the semantic of the cnd instruction for < 1.4 shaders */
1835 if(arg->opcode_token & WINED3DSI_COISSUE) {
1836 shader_addline(arg->buffer, "%s /* COISSUE! */);\n", src1_param.param_str);
1837 } else {
1838 shader_addline(arg->buffer, "%s > 0.5 ? %s : %s);\n",
1839 src0_param.param_str, src1_param.param_str, src2_param.param_str);
1840 }
1841 return;
1842 }
1843 /* Cycle through all source0 channels */
1844 for (i=0; i<4; i++) {
1845 write_mask = 0;
1846 /* Find the destination channels which use the current source0 channel */
1847 for (j=0; j<4; j++) {
1848 if ( ((arg->src[0] >> (WINED3DSP_SWIZZLE_SHIFT + 2*j)) & 0x3) == i ) {
1849 write_mask |= WINED3DSP_WRITEMASK_0 << j;
1850 cmp_channel = WINED3DSP_WRITEMASK_0 << j;
1851 }
1852 }
1853 write_mask = shader_glsl_append_dst_ext(arg->buffer, arg, arg->dst & (~WINED3DSP_SWIZZLE_MASK | write_mask));
1854 if (!write_mask) continue;
1855
1856 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], cmp_channel, &src0_param);
1857 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
1858 shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
1859
1860 shader_addline(arg->buffer, "%s > 0.5 ? %s : %s);\n",
1861 src0_param.param_str, src1_param.param_str, src2_param.param_str);
1862 }
1863 }
1864
1865 /** GLSL code generation for WINED3DSIO_MAD: Multiply the first 2 opcodes, then add the last */
1866 void shader_glsl_mad(SHADER_OPCODE_ARG* arg) {
1867 glsl_src_param_t src0_param;
1868 glsl_src_param_t src1_param;
1869 glsl_src_param_t src2_param;
1870 DWORD write_mask;
1871
1872 write_mask = shader_glsl_append_dst(arg->buffer, arg);
1873 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
1874 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
1875 shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
1876 shader_addline(arg->buffer, "(%s * %s) + %s);\n",
1877 src0_param.param_str, src1_param.param_str, src2_param.param_str);
1878 }
1879
1880 /** Handles transforming all WINED3DSIO_M?x? opcodes for
1881 Vertex shaders to GLSL codes */
1882 void shader_glsl_mnxn(SHADER_OPCODE_ARG* arg) {
1883 int i;
1884 int nComponents = 0;
1885 SHADER_OPCODE_ARG tmpArg;
1886
1887 memset(&tmpArg, 0, sizeof(SHADER_OPCODE_ARG));
1888
1889 /* Set constants for the temporary argument */
1890 tmpArg.shader = arg->shader;
1891 tmpArg.buffer = arg->buffer;
1892 tmpArg.src[0] = arg->src[0];
1893 tmpArg.src_addr[0] = arg->src_addr[0];
1894 tmpArg.src_addr[1] = arg->src_addr[1];
1895 tmpArg.reg_maps = arg->reg_maps;
1896
1897 switch(arg->opcode->opcode) {
1898 case WINED3DSIO_M4x4:
1899 nComponents = 4;
1900 tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP4);
1901 break;
1902 case WINED3DSIO_M4x3:
1903 nComponents = 3;
1904 tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP4);
1905 break;
1906 case WINED3DSIO_M3x4:
1907 nComponents = 4;
1908 tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
1909 break;
1910 case WINED3DSIO_M3x3:
1911 nComponents = 3;
1912 tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
1913 break;
1914 case WINED3DSIO_M3x2:
1915 nComponents = 2;
1916 tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
1917 break;
1918 default:
1919 break;
1920 }
1921
1922 for (i = 0; i < nComponents; i++) {
1923 tmpArg.dst = ((arg->dst) & ~WINED3DSP_WRITEMASK_ALL)|(WINED3DSP_WRITEMASK_0<<i);
1924 tmpArg.src[1] = arg->src[1]+i;
1925 shader_glsl_dot(&tmpArg);
1926 }
1927 }
1928
1929 /**
1930 The LRP instruction performs a component-wise linear interpolation
1931 between the second and third operands using the first operand as the
1932 blend factor. Equation: (dst = src2 + src0 * (src1 - src2))
1933 This is equivalent to mix(src2, src1, src0);
1934 */
1935 void shader_glsl_lrp(SHADER_OPCODE_ARG* arg) {
1936 glsl_src_param_t src0_param;
1937 glsl_src_param_t src1_param;
1938 glsl_src_param_t src2_param;
1939 DWORD write_mask;
1940
1941 write_mask = shader_glsl_append_dst(arg->buffer, arg);
1942
1943 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
1944 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
1945 shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
1946
1947 shader_addline(arg->buffer, "mix(%s, %s, %s));\n",
1948 src2_param.param_str, src1_param.param_str, src0_param.param_str);
1949 }
1950
1951 /** Process the WINED3DSIO_LIT instruction in GLSL:
1952 * dst.x = dst.w = 1.0
1953 * dst.y = (src0.x > 0) ? src0.x
1954 * dst.z = (src0.x > 0) ? ((src0.y > 0) ? pow(src0.y, src.w) : 0) : 0
1955 * where src.w is clamped at +- 128
1956 */
1957 void shader_glsl_lit(SHADER_OPCODE_ARG* arg) {
1958 glsl_src_param_t src0_param;
1959 glsl_src_param_t src1_param;
1960 glsl_src_param_t src3_param;
1961 char dst_mask[6];
1962
1963 shader_glsl_append_dst(arg->buffer, arg);
1964 shader_glsl_get_write_mask(arg->dst, dst_mask);
1965
1966 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
1967 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_1, &src1_param);
1968 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &src3_param);
1969
1970 /* The sdk specifies the instruction like this
1971 * dst.x = 1.0;
1972 * if(src.x > 0.0) dst.y = src.x
1973 * else dst.y = 0.0.
1974 * if(src.x > 0.0 && src.y > 0.0) dst.z = pow(src.y, power);
1975 * else dst.z = 0.0;
1976 * dst.w = 1.0;
1977 *
1978 * Obviously that has quite a few conditionals in it which we don't like. So the first step is this:
1979 * dst.x = 1.0 ... No further explanation needed
1980 * dst.y = max(src.y, 0.0); ... If x < 0.0, use 0.0, otherwise x. Same as the conditional
1981 * dst.z = x > 0.0 ? pow(max(y, 0.0), p) : 0; ... 0 ^ power is 0, and otherwise we use y anyway
1982 * dst.w = 1.0. ... Nothing fancy.
1983 *
1984 * So we still have one conditional in there. So do this:
1985 * dst.z = pow(max(0.0, src.y) * step(0.0, src.x), power);
1986 *
1987 * step(0.0, x) will return 1 if src.x > 0.0, and 0 otherwise. So if y is 0 we get pow(0.0 * 1.0, power),
1988 * which sets dst.z to 0. If y > 0, but x = 0.0, we get pow(y * 0.0, power), which results in 0 too.
1989 * if both x and y are > 0, we get pow(y * 1.0, power), as it is supposed to
1990 */
1991 shader_addline(arg->buffer, "vec4(1.0, max(%s, 0.0), pow(max(0.0, %s) * step(0.0, %s), clamp(%s, -128.0, 128.0)), 1.0)%s);\n",
1992 src0_param.param_str, src1_param.param_str, src0_param.param_str, src3_param.param_str, dst_mask);
1993 }
1994
1995 /** Process the WINED3DSIO_DST instruction in GLSL:
1996 * dst.x = 1.0
1997 * dst.y = src0.x * src0.y
1998 * dst.z = src0.z
1999 * dst.w = src1.w
2000 */
2001 void shader_glsl_dst(SHADER_OPCODE_ARG* arg) {
2002 glsl_src_param_t src0y_param;
2003 glsl_src_param_t src0z_param;
2004 glsl_src_param_t src1y_param;
2005 glsl_src_param_t src1w_param;
2006 char dst_mask[6];
2007
2008 shader_glsl_append_dst(arg->buffer, arg);
2009 shader_glsl_get_write_mask(arg->dst, dst_mask);
2010
2011 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_1, &src0y_param);
2012 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_2, &src0z_param);
2013 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_1, &src1y_param);
2014 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_3, &src1w_param);
2015
2016 shader_addline(arg->buffer, "vec4(1.0, %s * %s, %s, %s))%s;\n",
2017 src0y_param.param_str, src1y_param.param_str, src0z_param.param_str, src1w_param.param_str, dst_mask);
2018 }
2019
2020 /** Process the WINED3DSIO_SINCOS instruction in GLSL:
2021 * VS 2.0 requires that specific cosine and sine constants be passed to this instruction so the hardware
2022 * can handle it. But, these functions are built-in for GLSL, so we can just ignore the last 2 params.
2023 *
2024 * dst.x = cos(src0.?)
2025 * dst.y = sin(src0.?)
2026 * dst.z = dst.z
2027 * dst.w = dst.w
2028 */
2029 void shader_glsl_sincos(SHADER_OPCODE_ARG* arg) {
2030 glsl_src_param_t src0_param;
2031 DWORD write_mask;
2032
2033 write_mask = shader_glsl_append_dst(arg->buffer, arg);
2034 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
2035
2036 switch (write_mask) {
2037 case WINED3DSP_WRITEMASK_0:
2038 shader_addline(arg->buffer, "cos(%s));\n", src0_param.param_str);
2039 break;
2040
2041 case WINED3DSP_WRITEMASK_1:
2042 shader_addline(arg->buffer, "sin(%s));\n", src0_param.param_str);
2043 break;
2044
2045 case (WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1):
2046 shader_addline(arg->buffer, "vec2(cos(%s), sin(%s)));\n", src0_param.param_str, src0_param.param_str);
2047 break;
2048
2049 default:
2050 ERR("Write mask should be .x, .y or .xy\n");
2051 break;
2052 }
2053 }
2054
2055 /** Process the WINED3DSIO_LOOP instruction in GLSL:
2056 * Start a for() loop where src1.y is the initial value of aL,
2057 * increment aL by src1.z for a total of src1.x iterations.
2058 * Need to use a temporary variable for this operation.
2059 */
2060 /* FIXME: I don't think nested loops will work correctly this way. */
2061 void shader_glsl_loop(SHADER_OPCODE_ARG* arg) {
2062 glsl_src_param_t src1_param;
2063 IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
2064 DWORD regtype = shader_get_regtype(arg->src[1]);
2065 DWORD reg = arg->src[1] & WINED3DSP_REGNUM_MASK;
2066 const DWORD *control_values = NULL;
2067 local_constant *constant;
2068
2069 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_ALL, &src1_param);
2070
2071 /* Try to hardcode the loop control parameters if possible. Direct3D 9 class hardware doesn't support real
2072 * varying indexing, but Microsoft designed this feature for Shader model 2.x+. If the loop control is
2073 * known at compile time, the GLSL compiler can unroll the loop, and replace indirect addressing with direct
2074 * addressing.
2075 */
2076 if(regtype == WINED3DSPR_CONSTINT) {
2077 LIST_FOR_EACH_ENTRY(constant, &shader->baseShader.constantsI, local_constant, entry) {
2078 if(constant->idx == reg) {
2079 control_values = constant->value;
2080 break;
2081 }
2082 }
2083 }
2084
2085 if(control_values) {
2086 if(control_values[2] > 0) {
2087 shader_addline(arg->buffer, "for (aL%u = %d; aL%u < (%d * %d + %d); aL%u += %d) {\n",
2088 shader->baseShader.cur_loop_depth, control_values[1],
2089 shader->baseShader.cur_loop_depth, control_values[0], control_values[2], control_values[1],
2090 shader->baseShader.cur_loop_depth, control_values[2]);
2091 } else if(control_values[2] == 0) {
2092 shader_addline(arg->buffer, "for (aL%u = %d, tmpInt%u = 0; tmpInt%u < %d; tmpInt%u++) {\n",
2093 shader->baseShader.cur_loop_depth, control_values[1], shader->baseShader.cur_loop_depth,
2094 shader->baseShader.cur_loop_depth, control_values[0],
2095 shader->baseShader.cur_loop_depth);
2096 } else {
2097 shader_addline(arg->buffer, "for (aL%u = %d; aL%u > (%d * %d + %d); aL%u += %d) {\n",
2098 shader->baseShader.cur_loop_depth, control_values[1],
2099 shader->baseShader.cur_loop_depth, control_values[0], control_values[2], control_values[1],
2100 shader->baseShader.cur_loop_depth, control_values[2]);
2101 }
2102 } else {
2103 shader_addline(arg->buffer, "for (tmpInt%u = 0, aL%u = %s.y; tmpInt%u < %s.x; tmpInt%u++, aL%u += %s.z) {\n",
2104 shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_regno,
2105 src1_param.reg_name, shader->baseShader.cur_loop_depth, src1_param.reg_name,
2106 shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_regno, src1_param.reg_name);
2107 }
2108
2109 shader->baseShader.cur_loop_depth++;
2110 shader->baseShader.cur_loop_regno++;
2111 }
2112
2113 void shader_glsl_end(SHADER_OPCODE_ARG* arg) {
2114 IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
2115
2116 shader_addline(arg->buffer, "}\n");
2117
2118 if(arg->opcode->opcode == WINED3DSIO_ENDLOOP) {
2119 shader->baseShader.cur_loop_depth--;
2120 shader->baseShader.cur_loop_regno--;
2121 }
2122 if(arg->opcode->opcode == WINED3DSIO_ENDREP) {
2123 shader->baseShader.cur_loop_depth--;
2124 }
2125 }
2126
2127 void shader_glsl_rep(SHADER_OPCODE_ARG* arg) {
2128 IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
2129 glsl_src_param_t src0_param;
2130
2131 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
2132 shader_addline(arg->buffer, "for (tmpInt%d = 0; tmpInt%d < %s; tmpInt%d++) {\n",
2133 shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_depth,
2134 src0_param.param_str, shader->baseShader.cur_loop_depth);
2135 shader->baseShader.cur_loop_depth++;
2136 }
2137
2138 void shader_glsl_if(SHADER_OPCODE_ARG* arg) {
2139 glsl_src_param_t src0_param;
2140
2141 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
2142 shader_addline(arg->buffer, "if (%s) {\n", src0_param.param_str);
2143 }
2144
2145 void shader_glsl_ifc(SHADER_OPCODE_ARG* arg) {
2146 glsl_src_param_t src0_param;
2147 glsl_src_param_t src1_param;
2148
2149 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
2150 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
2151
2152 shader_addline(arg->buffer, "if (%s %s %s) {\n",
2153 src0_param.param_str, shader_get_comp_op(arg->opcode_token), src1_param.param_str);
2154 }
2155
2156 void shader_glsl_else(SHADER_OPCODE_ARG* arg) {
2157 shader_addline(arg->buffer, "} else {\n");
2158 }
2159
2160 void shader_glsl_break(SHADER_OPCODE_ARG* arg) {
2161 shader_addline(arg->buffer, "break;\n");
2162 }
2163
2164 /* FIXME: According to MSDN the compare is done per component. */
2165 void shader_glsl_breakc(SHADER_OPCODE_ARG* arg) {
2166 glsl_src_param_t src0_param;
2167 glsl_src_param_t src1_param;
2168
2169 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
2170 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
2171
2172 shader_addline(arg->buffer, "if (%s %s %s) break;\n",
2173 src0_param.param_str, shader_get_comp_op(arg->opcode_token), src1_param.param_str);
2174 }
2175
2176 void shader_glsl_label(SHADER_OPCODE_ARG* arg) {
2177
2178 DWORD snum = (arg->src[0]) & WINED3DSP_REGNUM_MASK;
2179 shader_addline(arg->buffer, "}\n");
2180 shader_addline(arg->buffer, "void subroutine%u () {\n", snum);
2181 }
2182
2183 void shader_glsl_call(SHADER_OPCODE_ARG* arg) {
2184 DWORD snum = (arg->src[0]) & WINED3DSP_REGNUM_MASK;
2185 shader_addline(arg->buffer, "subroutine%u();\n", snum);
2186 }
2187
2188 void shader_glsl_callnz(SHADER_OPCODE_ARG* arg) {
2189 glsl_src_param_t src1_param;
2190
2191 DWORD snum = (arg->src[0]) & WINED3DSP_REGNUM_MASK;
2192 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
2193 shader_addline(arg->buffer, "if (%s) subroutine%u();\n", src1_param.param_str, snum);
2194 }
2195
2196 /*********************************************
2197 * Pixel Shader Specific Code begins here
2198 ********************************************/
2199 void pshader_glsl_tex(SHADER_OPCODE_ARG* arg) {
2200 IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
2201 IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
2202 DWORD hex_version = This->baseShader.hex_version;
2203 char dst_swizzle[6];
2204 glsl_sample_function_t sample_function;
2205 DWORD sampler_type;
2206 DWORD sampler_idx;
2207 BOOL projected, texrect = FALSE;
2208 DWORD mask = 0;
2209
2210 /* All versions have a destination register */
2211 shader_glsl_append_dst(arg->buffer, arg);
2212
2213 /* 1.0-1.4: Use destination register as sampler source.
2214 * 2.0+: Use provided sampler source. */
2215 if (hex_version < WINED3DPS_VERSION(1,4)) {
2216 DWORD flags;
2217
2218 sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
2219 flags = deviceImpl->stateBlock->textureState[sampler_idx][WINED3DTSS_TEXTURETRANSFORMFLAGS];
2220
2221 if (flags & WINED3DTTFF_PROJECTED) {
2222 projected = TRUE;
2223 switch (flags & ~WINED3DTTFF_PROJECTED) {
2224 case WINED3DTTFF_COUNT1: FIXME("WINED3DTTFF_PROJECTED with WINED3DTTFF_COUNT1?\n"); break;
2225 case WINED3DTTFF_COUNT2: mask = WINED3DSP_WRITEMASK_1; break;
2226 case WINED3DTTFF_COUNT3: mask = WINED3DSP_WRITEMASK_2; break;
2227 case WINED3DTTFF_COUNT4:
2228 case WINED3DTTFF_DISABLE: mask = WINED3DSP_WRITEMASK_3; break;
2229 }
2230 } else {
2231 projected = FALSE;
2232 }
2233 } else if (hex_version < WINED3DPS_VERSION(2,0)) {
2234 DWORD src_mod = arg->src[0] & WINED3DSP_SRCMOD_MASK;
2235 sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
2236
2237 if (src_mod == WINED3DSPSM_DZ) {
2238 projected = TRUE;
2239 mask = WINED3DSP_WRITEMASK_2;
2240 } else if (src_mod == WINED3DSPSM_DW) {
2241 projected = TRUE;
2242 mask = WINED3DSP_WRITEMASK_3;
2243 } else {
2244 projected = FALSE;
2245 }
2246 } else {
2247 sampler_idx = arg->src[1] & WINED3DSP_REGNUM_MASK;
2248 if(arg->opcode_token & WINED3DSI_TEXLD_PROJECT) {
2249 /* ps 2.0 texldp instruction always divides by the fourth component. */
2250 projected = TRUE;
2251 mask = WINED3DSP_WRITEMASK_3;
2252 } else {
2253 projected = FALSE;
2254 }
2255 }
2256
2257 if(deviceImpl->stateBlock->textures[sampler_idx] &&
2258 IWineD3DBaseTexture_GetTextureDimensions(deviceImpl->stateBlock->textures[sampler_idx]) == GL_TEXTURE_RECTANGLE_ARB) {
2259 texrect = TRUE;
2260 }
2261
2262 sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
2263 shader_glsl_get_sample_function(sampler_type, projected, texrect, &sample_function);
2264 mask |= sample_function.coord_mask;
2265
2266 if (hex_version < WINED3DPS_VERSION(2,0)) {
2267 shader_glsl_get_write_mask(arg->dst, dst_swizzle);
2268 } else {
2269 shader_glsl_get_swizzle(arg->src[1], FALSE, arg->dst, dst_swizzle);
2270 }
2271
2272 /* 1.0-1.3: Use destination register as coordinate source.
2273 1.4+: Use provided coordinate source register. */
2274 if (hex_version < WINED3DPS_VERSION(1,4)) {
2275 char coord_mask[6];
2276 shader_glsl_get_write_mask(mask, coord_mask);
2277 shader_addline(arg->buffer, "%s(Psampler%u, T%u%s)%s);\n",
2278 sample_function.name, sampler_idx, sampler_idx, coord_mask, dst_swizzle);
2279 } else {
2280 glsl_src_param_t coord_param;
2281 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], mask, &coord_param);
2282 if(arg->opcode_token & WINED3DSI_TEXLD_BIAS) {
2283 glsl_src_param_t bias;
2284 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &bias);
2285
2286 shader_addline(arg->buffer, "%s(Psampler%u, %s, %s)%s);\n",
2287 sample_function.name, sampler_idx, coord_param.param_str,
2288 bias.param_str, dst_swizzle);
2289 } else {
2290 shader_addline(arg->buffer, "%s(Psampler%u, %s)%s);\n",
2291 sample_function.name, sampler_idx, coord_param.param_str, dst_swizzle);
2292 }
2293 }
2294 }
2295
2296 void shader_glsl_texldl(SHADER_OPCODE_ARG* arg) {
2297 IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*)arg->shader;
2298 IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
2299 glsl_sample_function_t sample_function;
2300 glsl_src_param_t coord_param, lod_param;
2301 char dst_swizzle[6];
2302 DWORD sampler_type;
2303 DWORD sampler_idx;
2304 BOOL texrect = FALSE;
2305
2306 shader_glsl_append_dst(arg->buffer, arg);
2307 shader_glsl_get_swizzle(arg->src[1], FALSE, arg->dst, dst_swizzle);
2308
2309 sampler_idx = arg->src[1] & WINED3DSP_REGNUM_MASK;
2310 sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
2311 if(deviceImpl->stateBlock->textures[sampler_idx] &&
2312 IWineD3DBaseTexture_GetTextureDimensions(deviceImpl->stateBlock->textures[sampler_idx]) == GL_TEXTURE_RECTANGLE_ARB) {
2313 texrect = TRUE;
2314 }
2315 shader_glsl_get_sample_function(sampler_type, FALSE, texrect, &sample_function); shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], sample_function.coord_mask, &coord_param);
2316
2317 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &lod_param);
2318
2319 if (shader_is_pshader_version(This->baseShader.hex_version)) {
2320 /* The GLSL spec claims the Lod sampling functions are only supported in vertex shaders.
2321 * However, they seem to work just fine in fragment shaders as well. */
2322 WARN("Using %sLod in fragment shader.\n", sample_function.name);
2323 shader_addline(arg->buffer, "%sLod(Psampler%u, %s, %s)%s);\n",
2324 sample_function.name, sampler_idx, coord_param.param_str, lod_param.param_str, dst_swizzle);
2325 } else {
2326 shader_addline(arg->buffer, "%sLod(Vsampler%u, %s, %s)%s);\n",
2327 sample_function.name, sampler_idx, coord_param.param_str, lod_param.param_str, dst_swizzle);
2328 }
2329 }
2330
2331 void pshader_glsl_texcoord(SHADER_OPCODE_ARG* arg) {
2332
2333 /* FIXME: Make this work for more than just 2D textures */
2334
2335 IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
2336 SHADER_BUFFER* buffer = arg->buffer;
2337 DWORD hex_version = This->baseShader.hex_version;
2338 DWORD write_mask;
2339 char dst_mask[6];
2340
2341 write_mask = shader_glsl_append_dst(arg->buffer, arg);
2342 shader_glsl_get_write_mask(write_mask, dst_mask);
2343
2344 if (hex_version != WINED3DPS_VERSION(1,4)) {
2345 DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
2346 shader_addline(buffer, "clamp(gl_TexCoord[%u], 0.0, 1.0)%s);\n", reg, dst_mask);
2347 } else {
2348 DWORD reg = arg->src[0] & WINED3DSP_REGNUM_MASK;
2349 DWORD src_mod = arg->src[0] & WINED3DSP_SRCMOD_MASK;
2350 char dst_swizzle[6];
2351
2352 shader_glsl_get_swizzle(arg->src[0], FALSE, write_mask, dst_swizzle);
2353
2354 if (src_mod == WINED3DSPSM_DZ) {
2355 glsl_src_param_t div_param;
2356 unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
2357 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_2, &div_param);
2358
2359 if (mask_size > 1) {
2360 shader_addline(buffer, "gl_TexCoord[%u]%s / vec%d(%s));\n", reg, dst_swizzle, mask_size, div_param.param_str);
2361 } else {
2362 shader_addline(buffer, "gl_TexCoord[%u]%s / %s);\n", reg, dst_swizzle, div_param.param_str);
2363 }
2364 } else if (src_mod == WINED3DSPSM_DW) {
2365 glsl_src_param_t div_param;
2366 unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
2367 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &div_param);
2368
2369 if (mask_size > 1) {
2370 shader_addline(buffer, "gl_TexCoord[%u]%s / vec%d(%s));\n", reg, dst_swizzle, mask_size, div_param.param_str);
2371 } else {
2372 shader_addline(buffer, "gl_TexCoord[%u]%s / %s);\n", reg, dst_swizzle, div_param.param_str);
2373 }
2374 } else {
2375 shader_addline(buffer, "gl_TexCoord[%u]%s);\n", reg, dst_swizzle);
2376 }
2377 }
2378 }
2379
2380 /** Process the WINED3DSIO_TEXDP3TEX instruction in GLSL:
2381 * Take a 3-component dot product of the TexCoord[dstreg] and src,
2382 * then perform a 1D texture lookup from stage dstregnum, place into dst. */
2383 void pshader_glsl_texdp3tex(SHADER_OPCODE_ARG* arg) {
2384 glsl_src_param_t src0_param;
2385 char dst_mask[6];
2386 glsl_sample_function_t sample_function;
2387 DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
2388 DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2389 DWORD sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
2390
2391 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2392
2393 shader_glsl_append_dst(arg->buffer, arg);
2394 shader_glsl_get_write_mask(arg->dst, dst_mask);
2395
2396 /* Do I have to take care about the projected bit? I don't think so, since the dp3 returns only one
2397 * scalar, and projected sampling would require 4.
2398 *
2399 * It is a dependent read - not valid with conditional NP2 textures
2400 */
2401 shader_glsl_get_sample_function(sampler_type, FALSE, FALSE, &sample_function);
2402
2403 switch(count_bits(sample_function.coord_mask)) {
2404 case 1:
2405 shader_addline(arg->buffer, "%s(Psampler%u, dot(gl_TexCoord[%u].xyz, %s))%s);\n",
2406 sample_function.name, sampler_idx, sampler_idx, src0_param.param_str, dst_mask);
2407 break;
2408
2409 case 2:
2410 shader_addline(arg->buffer, "%s(Psampler%u, vec2(dot(gl_TexCoord[%u].xyz, %s), 0.0))%s);\n",
2411 sample_function.name, sampler_idx, sampler_idx, src0_param.param_str, dst_mask);
2412 break;
2413
2414 case 3:
2415 shader_addline(arg->buffer, "%s(Psampler%u, vec3(dot(gl_TexCoord[%u].xyz, %s), 0.0, 0.0))%s);\n",
2416 sample_function.name, sampler_idx, sampler_idx, src0_param.param_str, dst_mask);
2417 break;
2418 default:
2419 FIXME("Unexpected mask bitcount %d\n", count_bits(sample_function.coord_mask));
2420 }
2421 }
2422
2423 /** Process the WINED3DSIO_TEXDP3 instruction in GLSL:
2424 * Take a 3-component dot product of the TexCoord[dstreg] and src. */
2425 void pshader_glsl_texdp3(SHADER_OPCODE_ARG* arg) {
2426 glsl_src_param_t src0_param;
2427 DWORD dstreg = arg->dst & WINED3DSP_REGNUM_MASK;
2428 DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2429 DWORD dst_mask;
2430 unsigned int mask_size;
2431
2432 dst_mask = shader_glsl_append_dst(arg->buffer, arg);
2433 mask_size = shader_glsl_get_write_mask_size(dst_mask);
2434 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2435
2436 if (mask_size > 1) {
2437 shader_addline(arg->buffer, "vec%d(dot(T%u.xyz, %s)));\n", mask_size, dstreg, src0_param.param_str);
2438 } else {
2439 shader_addline(arg->buffer, "dot(T%u.xyz, %s));\n", dstreg, src0_param.param_str);
2440 }
2441 }
2442
2443 /** Process the WINED3DSIO_TEXDEPTH instruction in GLSL:
2444 * Calculate the depth as dst.x / dst.y */
2445 void pshader_glsl_texdepth(SHADER_OPCODE_ARG* arg) {
2446 glsl_dst_param_t dst_param;
2447
2448 shader_glsl_add_dst_param(arg, arg->dst, 0, &dst_param);
2449
2450 /* Tests show that texdepth never returns anything below 0.0, and that r5.y is clamped to 1.0.
2451 * Negative input is accepted, -0.25 / -0.5 returns 0.5. GL should clamp gl_FragDepth to [0;1], but
2452 * this doesn't always work, so clamp the results manually. Whether or not the x value is clamped at 1
2453 * too is irrelevant, since if x = 0, any y value < 1.0 (and > 1.0 is not allowed) results in a result
2454 * >= 1.0 or < 0.0
2455 */
2456 shader_addline(arg->buffer, "gl_FragDepth = clamp((%s.x / min(%s.y, 1.0)), 0.0, 1.0);\n", dst_param.reg_name, dst_param.reg_name);
2457 }
2458
2459 /** Process the WINED3DSIO_TEXM3X2DEPTH instruction in GLSL:
2460 * Last row of a 3x2 matrix multiply, use the result to calculate the depth:
2461 * Calculate tmp0.y = TexCoord[dstreg] . src.xyz; (tmp0.x has already been calculated)
2462 * depth = (tmp0.y == 0.0) ? 1.0 : tmp0.x / tmp0.y
2463 */
2464 void pshader_glsl_texm3x2depth(SHADER_OPCODE_ARG* arg) {
2465 DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2466 DWORD dstreg = arg->dst & WINED3DSP_REGNUM_MASK;
2467 glsl_src_param_t src0_param;
2468
2469 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2470
2471 shader_addline(arg->buffer, "tmp0.y = dot(T%u.xyz, %s);\n", dstreg, src0_param.param_str);
2472 shader_addline(arg->buffer, "gl_FragDepth = (tmp0.y == 0.0) ? 1.0 : clamp(tmp0.x / tmp0.y, 0.0, 1.0);\n");
2473 }
2474
2475 /** Process the WINED3DSIO_TEXM3X2PAD instruction in GLSL
2476 * Calculate the 1st of a 2-row matrix multiplication. */
2477 void pshader_glsl_texm3x2pad(SHADER_OPCODE_ARG* arg) {
2478 DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2479 DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
2480 SHADER_BUFFER* buffer = arg->buffer;
2481 glsl_src_param_t src0_param;
2482
2483 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2484 shader_addline(buffer, "tmp0.x = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
2485 }
2486
2487 /** Process the WINED3DSIO_TEXM3X3PAD instruction in GLSL
2488 * Calculate the 1st or 2nd row of a 3-row matrix multiplication. */
2489 void pshader_glsl_texm3x3pad(SHADER_OPCODE_ARG* arg) {
2490
2491 IWineD3DPixelShaderImpl* shader = (IWineD3DPixelShaderImpl*) arg->shader;
2492 DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2493 DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
2494 SHADER_BUFFER* buffer = arg->buffer;
2495 SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
2496 glsl_src_param_t src0_param;
2497
2498 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2499 shader_addline(buffer, "tmp0.%c = dot(T%u.xyz, %s);\n", 'x' + current_state->current_row, reg, src0_param.param_str);
2500 current_state->texcoord_w[current_state->current_row++] = reg;
2501 }
2502
2503 void pshader_glsl_texm3x2tex(SHADER_OPCODE_ARG* arg) {
2504 DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2505 DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
2506 SHADER_BUFFER* buffer = arg->buffer;
2507 glsl_src_param_t src0_param;
2508 char dst_mask[6];
2509
2510 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2511 shader_addline(buffer, "tmp0.y = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
2512
2513 shader_glsl_append_dst(buffer, arg);
2514 shader_glsl_get_write_mask(arg->dst, dst_mask);
2515
2516 /* Sample the texture using the calculated coordinates */
2517 shader_addline(buffer, "texture2D(Psampler%u, tmp0.xy)%s);\n", reg, dst_mask);
2518 }
2519
2520 /** Process the WINED3DSIO_TEXM3X3TEX instruction in GLSL
2521 * Perform the 3rd row of a 3x3 matrix multiply, then sample the texture using the calculated coordinates */
2522 void pshader_glsl_texm3x3tex(SHADER_OPCODE_ARG* arg) {
2523 DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2524 glsl_src_param_t src0_param;
2525 char dst_mask[6];
2526 DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
2527 IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
2528 SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
2529 DWORD sampler_type = arg->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
2530 glsl_sample_function_t sample_function;
2531
2532 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2533 shader_addline(arg->buffer, "tmp0.z = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
2534
2535 shader_glsl_append_dst(arg->buffer, arg);
2536 shader_glsl_get_write_mask(arg->dst, dst_mask);
2537 /* Dependent read, not valid with conditional NP2 */
2538 shader_glsl_get_sample_function(sampler_type, FALSE, FALSE, &sample_function);
2539
2540 /* Sample the texture using the calculated coordinates */
2541 shader_addline(arg->buffer, "%s(Psampler%u, tmp0.xyz)%s);\n", sample_function.name, reg, dst_mask);
2542
2543 current_state->current_row = 0;
2544 }
2545
2546 /** Process the WINED3DSIO_TEXM3X3 instruction in GLSL
2547 * Perform the 3rd row of a 3x3 matrix multiply */
2548 void pshader_glsl_texm3x3(SHADER_OPCODE_ARG* arg) {
2549 DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2550 glsl_src_param_t src0_param;
2551 char dst_mask[6];
2552 DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
2553 IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
2554 SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
2555
2556 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2557
2558 shader_glsl_append_dst(arg->buffer, arg);
2559 shader_glsl_get_write_mask(arg->dst, dst_mask);
2560 shader_addline(arg->buffer, "vec4(tmp0.xy, dot(T%u.xyz, %s), 1.0)%s);\n", reg, src0_param.param_str, dst_mask);
2561
2562 current_state->current_row = 0;
2563 }
2564
2565 /** Process the WINED3DSIO_TEXM3X3SPEC instruction in GLSL
2566 * Peform the final texture lookup based on the previous 2 3x3 matrix multiplies */
2567 void pshader_glsl_texm3x3spec(SHADER_OPCODE_ARG* arg) {
2568
2569 IWineD3DPixelShaderImpl* shader = (IWineD3DPixelShaderImpl*) arg->shader;
2570 DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
2571 glsl_src_param_t src0_param;
2572 glsl_src_param_t src1_param;
2573 char dst_mask[6];
2574 SHADER_BUFFER* buffer = arg->buffer;
2575 SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
2576 DWORD stype = arg->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
2577 DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2578 glsl_sample_function_t sample_function;
2579
2580 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2581 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], src_mask, &src1_param);
2582
2583 /* Perform the last matrix multiply operation */
2584 shader_addline(buffer, "tmp0.z = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
2585 /* Reflection calculation */
2586 shader_addline(buffer, "tmp0.xyz = -reflect((%s), normalize(tmp0.xyz));\n", src1_param.param_str);
2587
2588 shader_glsl_append_dst(buffer, arg);
2589 shader_glsl_get_write_mask(arg->dst, dst_mask);
2590 /* Dependent read, not valid with conditional NP2 */
2591 shader_glsl_get_sample_function(stype, FALSE, FALSE, &sample_function);
2592
2593 /* Sample the texture */
2594 shader_addline(buffer, "%s(Psampler%u, tmp0.xyz)%s);\n", sample_function.name, reg, dst_mask);
2595
2596 current_state->current_row = 0;
2597 }
2598
2599 /** Process the WINED3DSIO_TEXM3X3VSPEC instruction in GLSL
2600 * Peform the final texture lookup based on the previous 2 3x3 matrix multiplies */
2601 void pshader_glsl_texm3x3vspec(SHADER_OPCODE_ARG* arg) {
2602
2603 IWineD3DPixelShaderImpl* shader = (IWineD3DPixelShaderImpl*) arg->shader;
2604 DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
2605 SHADER_BUFFER* buffer = arg->buffer;
2606 SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
2607 glsl_src_param_t src0_param;
2608 char dst_mask[6];
2609 DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2610 DWORD sampler_type = arg->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
2611 glsl_sample_function_t sample_function;
2612
2613 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2614
2615 /* Perform the last matrix multiply operation */
2616 shader_addline(buffer, "tmp0.z = dot(vec3(T%u), vec3(%s));\n", reg, src0_param.param_str);
2617
2618 /* Construct the eye-ray vector from w coordinates */
2619 shader_addline(buffer, "tmp1.xyz = normalize(vec3(gl_TexCoord[%u].w, gl_TexCoord[%u].w, gl_TexCoord[%u].w));\n",
2620 current_state->texcoord_w[0], current_state->texcoord_w[1], reg);
2621 shader_addline(buffer, "tmp0.xyz = -reflect(tmp1.xyz, normalize(tmp0.xyz));\n");
2622
2623 shader_glsl_append_dst(buffer, arg);
2624 shader_glsl_get_write_mask(arg->dst, dst_mask);
2625 /* Dependent read, not valid with conditional NP2 */
2626 shader_glsl_get_sample_function(sampler_type, FALSE, FALSE, &sample_function);
2627
2628 /* Sample the texture using the calculated coordinates */
2629 shader_addline(buffer, "%s(Psampler%u, tmp0.xyz)%s);\n", sample_function.name, reg, dst_mask);
2630
2631 current_state->current_row = 0;
2632 }
2633
2634 /** Process the WINED3DSIO_TEXBEM instruction in GLSL.
2635 * Apply a fake bump map transform.
2636 * texbem is pshader <= 1.3 only, this saves a few version checks
2637 */
2638 void pshader_glsl_texbem(SHADER_OPCODE_ARG* arg) {
2639 IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
2640 IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
2641 char dst_swizzle[6];
2642 glsl_sample_function_t sample_function;
2643 glsl_src_param_t coord_param;
2644 DWORD sampler_type;
2645 DWORD sampler_idx;
2646 DWORD mask;
2647 DWORD flags;
2648 char coord_mask[6];
2649
2650 sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
2651 flags = deviceImpl->stateBlock->textureState[sampler_idx][WINED3DTSS_TEXTURETRANSFORMFLAGS];
2652
2653 sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
2654 /* Dependent read, not valid with conditional NP2 */
2655 shader_glsl_get_sample_function(sampler_type, FALSE, FALSE, &sample_function);
2656 mask = sample_function.coord_mask;
2657
2658 shader_glsl_get_write_mask(arg->dst, dst_swizzle);
2659
2660 shader_glsl_get_write_mask(mask, coord_mask);
2661
2662 /* with projective textures, texbem only divides the static texture coord, not the displacement,
2663 * so we can't let the GL handle this.
2664 */
2665 if (flags & WINED3DTTFF_PROJECTED) {
2666 DWORD div_mask=0;
2667 char coord_div_mask[3];
2668 switch (flags & ~WINED3DTTFF_PROJECTED) {
2669 case WINED3DTTFF_COUNT1: FIXME("WINED3DTTFF_PROJECTED with WINED3DTTFF_COUNT1?\n"); break;
2670 case WINED3DTTFF_COUNT2: div_mask = WINED3DSP_WRITEMASK_1; break;
2671 case WINED3DTTFF_COUNT3: div_mask = WINED3DSP_WRITEMASK_2; break;
2672 case WINED3DTTFF_COUNT4:
2673 case WINED3DTTFF_DISABLE: div_mask = WINED3DSP_WRITEMASK_3; break;
2674 }
2675 shader_glsl_get_write_mask(div_mask, coord_div_mask);
2676 shader_addline(arg->buffer, "T%u%s /= T%u%s;\n", sampler_idx, coord_mask, sampler_idx, coord_div_mask);
2677 }
2678
2679 shader_glsl_append_dst(arg->buffer, arg);
2680 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0|WINED3DSP_WRITEMASK_1, &coord_param);
2681 if(arg->opcode->opcode == WINED3DSIO_TEXBEML) {
2682 glsl_src_param_t luminance_param;
2683 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_2, &luminance_param);
2684 shader_addline(arg->buffer, "(%s(Psampler%u, T%u%s + vec4(bumpenvmat%d * %s, 0.0, 0.0)%s )*(%s * luminancescale%d + luminanceoffset%d))%s);\n",
2685 sample_function.name, sampler_idx, sampler_idx, coord_mask, sampler_idx, coord_param.param_str, coord_mask,
2686 luminance_param.param_str, sampler_idx, sampler_idx, dst_swizzle);
2687 } else {
2688 shader_addline(arg->buffer, "%s(Psampler%u, T%u%s + vec4(bumpenvmat%d * %s, 0.0, 0.0)%s )%s);\n",
2689 sample_function.name, sampler_idx, sampler_idx, coord_mask, sampler_idx, coord_param.param_str, coord_mask, dst_swizzle);
2690 }
2691 }
2692
2693 void pshader_glsl_bem(SHADER_OPCODE_ARG* arg) {
2694 glsl_src_param_t src0_param, src1_param;
2695 DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
2696
2697 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0|WINED3DSP_WRITEMASK_1, &src0_param);
2698 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0|WINED3DSP_WRITEMASK_1, &src1_param);
2699
2700 shader_glsl_append_dst(arg->buffer, arg);
2701 shader_addline(arg->buffer, "%s + bumpenvmat%d * %s);\n",
2702 src0_param.param_str, sampler_idx, src1_param.param_str);
2703 }
2704
2705 /** Process the WINED3DSIO_TEXREG2AR instruction in GLSL
2706 * Sample 2D texture at dst using the alpha & red (wx) components of src as texture coordinates */
2707 void pshader_glsl_texreg2ar(SHADER_OPCODE_ARG* arg) {
2708
2709 glsl_src_param_t src0_param;
2710 DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
2711 char dst_mask[6];
2712
2713 shader_glsl_append_dst(arg->buffer, arg);
2714 shader_glsl_get_write_mask(arg->dst, dst_mask);
2715 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
2716
2717 shader_addline(arg->buffer, "texture2D(Psampler%u, %s.wx)%s);\n", sampler_idx, src0_param.reg_name, dst_mask);
2718 }
2719
2720 /** Process the WINED3DSIO_TEXREG2GB instruction in GLSL
2721 * Sample 2D texture at dst using the green & blue (yz) components of src as texture coordinates */
2722 void pshader_glsl_texreg2gb(SHADER_OPCODE_ARG* arg) {
2723 glsl_src_param_t src0_param;
2724 DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
2725 char dst_mask[6];
2726
2727 shader_glsl_append_dst(arg->buffer, arg);
2728 shader_glsl_get_write_mask(arg->dst, dst_mask);
2729 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
2730
2731 shader_addline(arg->buffer, "texture2D(Psampler%u, %s.yz)%s);\n", sampler_idx, src0_param.reg_name, dst_mask);
2732 }
2733
2734 /** Process the WINED3DSIO_TEXREG2RGB instruction in GLSL
2735 * Sample texture at dst using the rgb (xyz) components of src as texture coordinates */
2736 void pshader_glsl_texreg2rgb(SHADER_OPCODE_ARG* arg) {
2737 glsl_src_param_t src0_param;
2738 char dst_mask[6];
2739 DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
2740 DWORD sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
2741 glsl_sample_function_t sample_function;
2742
2743 shader_glsl_append_dst(arg->buffer, arg);
2744 shader_glsl_get_write_mask(arg->dst, dst_mask);
2745 /* Dependent read, not valid with conditional NP2 */
2746 shader_glsl_get_sample_function(sampler_type, FALSE, FALSE, &sample_function);
2747 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], sample_function.coord_mask, &src0_param);
2748
2749 shader_addline(arg->buffer, "%s(Psampler%u, %s)%s);\n", sample_function.name, sampler_idx, src0_param.param_str, dst_mask);
2750 }
2751
2752 /** Process the WINED3DSIO_TEXKILL instruction in GLSL.
2753 * If any of the first 3 components are < 0, discard this pixel */
2754 void pshader_glsl_texkill(SHADER_OPCODE_ARG* arg) {
2755 IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
2756 DWORD hex_version = This->baseShader.hex_version;
2757 glsl_dst_param_t dst_param;
2758
2759 /* The argument is a destination parameter, and no writemasks are allowed */
2760 shader_glsl_add_dst_param(arg, arg->dst, 0, &dst_param);
2761 if((hex_version >= WINED3DPS_VERSION(2,0))) {
2762 /* 2.0 shaders compare all 4 components in texkill */
2763 shader_addline(arg->buffer, "if (any(lessThan(%s.xyzw, vec4(0.0)))) discard;\n", dst_param.reg_name);
2764 } else {
2765 /* 1.X shaders only compare the first 3 components, probably due to the nature of the texkill
2766 * instruction as a tex* instruction, and phase, which kills all a / w components. Even if all
2767 * 4 components are defined, only the first 3 are used
2768 */
2769 shader_addline(arg->buffer, "if (any(lessThan(%s.xyz, vec3(0.0)))) discard;\n", dst_param.reg_name);
2770 }
2771 }
2772
2773 /** Process the WINED3DSIO_DP2ADD instruction in GLSL.
2774 * dst = dot2(src0, src1) + src2 */
2775 void pshader_glsl_dp2add(SHADER_OPCODE_ARG* arg) {
2776 glsl_src_param_t src0_param;
2777 glsl_src_param_t src1_param;
2778 glsl_src_param_t src2_param;
2779 DWORD write_mask;
2780 unsigned int mask_size;
2781
2782 write_mask = shader_glsl_append_dst(arg->buffer, arg);
2783 mask_size = shader_glsl_get_write_mask_size(write_mask);
2784
2785 shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src0_param);
2786 shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src1_param);
2787 shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], WINED3DSP_WRITEMASK_0, &src2_param);
2788
2789 if (mask_size > 1) {
2790 shader_addline(arg->buffer, "vec%d(dot(%s, %s) + %s));\n", mask_size, src0_param.param_str, src1_param.param_str, src2_param.param_str);
2791 } else {
2792 shader_addline(arg->buffer, "dot(%s, %s) + %s);\n", src0_param.param_str, src1_param.param_str, src2_param.param_str);
2793 }
2794 }
2795
2796 static void pshader_glsl_input_pack(
2797 SHADER_BUFFER* buffer,
2798 semantic* semantics_in,
2799 IWineD3DPixelShader *iface) {
2800
2801 unsigned int i;
2802 IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *) iface;
2803
2804 for (i = 0; i < MAX_REG_INPUT; i++) {
2805
2806 DWORD usage_token = semantics_in[i].usage;
2807 DWORD register_token = semantics_in[i].reg;
2808 DWORD usage, usage_idx;
2809 char reg_mask[6];
2810
2811 /* Uninitialized */
2812 if (!usage_token) continue;
2813 usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
2814 usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
2815 shader_glsl_get_write_mask(register_token, reg_mask);
2816
2817 switch(usage) {
2818
2819 case WINED3DDECLUSAGE_TEXCOORD:
2820 if(usage_idx < 8 && This->vertexprocessing == pretransformed) {
2821 shader_addline(buffer, "IN[%u]%s = gl_TexCoord[%u]%s;\n",
2822 This->input_reg_map[i], reg_mask, usage_idx, reg_mask);
2823 } else {
2824 shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
2825 This->input_reg_map[i], reg_mask, reg_mask);
2826 }
2827 break;
2828
2829 case WINED3DDECLUSAGE_COLOR:
2830 if (usage_idx == 0)
2831 shader_addline(buffer, "IN[%u]%s = vec4(gl_Color)%s;\n",
2832 This->input_reg_map[i], reg_mask, reg_mask);
2833 else if (usage_idx == 1)
2834 shader_addline(buffer, "IN[%u]%s = vec4(gl_SecondaryColor)%s;\n",
2835 This->input_reg_map[i], reg_mask, reg_mask);
2836 else
2837 shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
2838 This->input_reg_map[i], reg_mask, reg_mask);
2839 break;
2840
2841 default:
2842 shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
2843 This->input_reg_map[i], reg_mask, reg_mask);
2844 }
2845 }
2846 }
2847
2848 /*********************************************
2849 * Vertex Shader Specific Code begins here
2850 ********************************************/
2851
2852 static void add_glsl_program_entry(struct shader_glsl_priv *priv, struct glsl_shader_prog_link *entry) {
2853 glsl_program_key_t *key;
2854
2855 key = HeapAlloc(GetProcessHeap(), 0, sizeof(glsl_program_key_t));
2856 key->vshader = entry->vshader;
2857 key->pshader = entry->pshader;
2858
2859 hash_table_put(priv->glsl_program_lookup, key, entry);
2860 }
2861
2862 static struct glsl_shader_prog_link *get_glsl_program_entry(struct shader_glsl_priv *priv,
2863 GLhandleARB vshader, GLhandleARB pshader) {
2864 glsl_program_key_t key;
2865
2866 key.vshader = vshader;
2867 key.pshader = pshader;
2868
2869 return (struct glsl_shader_prog_link *)hash_table_get(priv->glsl_program_lookup, &key);
2870 }
2871
2872 static void delete_glsl_program_entry(struct shader_glsl_priv *priv, WineD3D_GL_Info *gl_info, struct glsl_shader_prog_link *entry) {
2873 glsl_program_key_t *key;
2874
2875 key = HeapAlloc(GetProcessHeap(), 0, sizeof(glsl_program_key_t));
2876 key->vshader = entry->vshader;
2877 key->pshader = entry->pshader;
2878 hash_table_remove(priv->glsl_program_lookup, key);
2879
2880 GL_EXTCALL(glDeleteObjectARB(entry->programId));
2881 if (entry->vshader) list_remove(&entry->vshader_entry);
2882 if (entry->pshader) list_remove(&entry->pshader_entry);
2883 HeapFree(GetProcessHeap(), 0, entry->vuniformF_locations);
2884 HeapFree(GetProcessHeap(), 0, entry->puniformF_locations);
2885 HeapFree(GetProcessHeap(), 0, entry);
2886 }
2887
2888 static void handle_ps3_input(SHADER_BUFFER *buffer, semantic *semantics_in, semantic *semantics_out, WineD3D_GL_Info *gl_info, DWORD *map) {
2889 unsigned int i, j;
2890 DWORD usage_token, usage_token_out;
2891 DWORD register_token, register_token_out;
2892 DWORD usage, usage_idx, usage_out, usage_idx_out;
2893 DWORD *set;
2894 DWORD in_idx;
2895 DWORD in_count = GL_LIMITS(glsl_varyings) / 4;
2896 char reg_mask[6], reg_mask_out[6];
2897 char destination[50];
2898
2899 set = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*set) * (in_count + 2));
2900
2901 if (!semantics_out) {
2902 /* Save gl_FrontColor & gl_FrontSecondaryColor before overwriting them. */
2903 shader_addline(buffer, "vec4 front_color = gl_FrontColor;\n");
2904 shader_addline(buffer, "vec4 front_secondary_color = gl_FrontSecondaryColor;\n");
2905 }
2906
2907 for(i = 0; i < MAX_REG_INPUT; i++) {
2908 usage_token = semantics_in[i].usage;
2909 if (!usage_token) continue;
2910
2911 in_idx = map[i];
2912 if (in_idx >= (in_count + 2)) {
2913 FIXME("More input varyings declared than supported, expect issues\n");
2914 continue;
2915 } else if(map[i] == -1) {
2916 /* Declared, but not read register */
2917 continue;
2918 }
2919
2920 if (in_idx == in_count) {
2921 sprintf(destination, "gl_FrontColor");
2922 } else if (in_idx == in_count + 1) {
2923 sprintf(destination, "gl_FrontSecondaryColor");
2924 } else {
2925 sprintf(destination, "IN[%u]", in_idx);
2926 }
2927
2928 register_token = semantics_in[i].reg;
2929
2930 usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
2931 usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
2932 set[map[i]] = shader_glsl_get_write_mask(register_token, reg_mask);
2933
2934 if(!semantics_out) {
2935 switch(usage) {
2936 case WINED3DDECLUSAGE_COLOR:
2937 if (usage_idx == 0)
2938 shader_addline(buffer, "%s%s = front_color%s;\n",
2939 destination, reg_mask, reg_mask);
2940 else if (usage_idx == 1)
2941 shader_addline(buffer, "%s%s = front_secondary_color%s;\n",
2942 destination, reg_mask, reg_mask);
2943 else
2944 shader_addline(buffer, "%s%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
2945 destination, reg_mask, reg_mask);
2946 break;
2947
2948 case WINED3DDECLUSAGE_TEXCOORD:
2949 if (usage_idx < 8) {
2950 shader_addline(buffer, "%s%s = gl_TexCoord[%u]%s;\n",
2951 destination, reg_mask, usage_idx, reg_mask);
2952 } else {
2953 shader_addline(buffer, "%s%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
2954 destination, reg_mask, reg_mask);
2955 }
2956 break;
2957
2958 case WINED3DDECLUSAGE_FOG:
2959 shader_addline(buffer, "%s%s = vec4(gl_FogFragCoord, 0.0, 0.0, 0.0)%s;\n",
2960 destination, reg_mask, reg_mask);
2961 break;
2962
2963 default:
2964 shader_addline(buffer, "%s%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
2965 destination, reg_mask, reg_mask);
2966 }
2967 } else {
2968 BOOL found = FALSE;
2969 for(j = 0; j < MAX_REG_OUTPUT; j++) {
2970 usage_token_out = semantics_out[j].usage;
2971 if (!usage_token_out) continue;
2972 register_token_out = semantics_out[j].reg;
2973
2974 usage_out = (usage_token_out & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
2975 usage_idx_out = (usage_token_out & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
2976 shader_glsl_get_write_mask(register_token_out, reg_mask_out);
2977
2978 if(usage == usage_out &&
2979 usage_idx == usage_idx_out) {
2980 shader_addline(buffer, "%s%s = OUT[%u]%s;\n",
2981 destination, reg_mask, j, reg_mask);
2982 found = TRUE;
2983 }
2984 }
2985 if(!found) {
2986 shader_addline(buffer, "%s%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
2987 destination, reg_mask, reg_mask);
2988 }
2989 }
2990 }
2991
2992 /* This is solely to make the compiler / linker happy and avoid warning about undefined
2993 * varyings. It shouldn't result in any real code executed on the GPU, since all read
2994 * input varyings are assigned above, if the optimizer works properly.
2995 */
2996 for(i = 0; i < in_count + 2; i++) {
2997 if(set[i] != WINED3DSP_WRITEMASK_ALL) {
2998 unsigned int size = 0;
2999 memset(reg_mask, 0, sizeof(reg_mask));
3000 if(!(set[i] & WINED3DSP_WRITEMASK_0)) {
3001 reg_mask[size] = 'x';
3002 size++;
3003 }
3004 if(!(set[i] & WINED3DSP_WRITEMASK_1)) {
3005 reg_mask[size] = 'y';
3006 size++;
3007 }
3008 if(!(set[i] & WINED3DSP_WRITEMASK_2)) {
3009 reg_mask[size] = 'z';
3010 size++;
3011 }
3012 if(!(set[i] & WINED3DSP_WRITEMASK_3)) {
3013 reg_mask[size] = 'w';
3014 size++;
3015 }
3016
3017 if (i == in_count) {
3018 sprintf(destination, "gl_FrontColor");
3019 } else if (i == in_count + 1) {
3020 sprintf(destination, "gl_FrontSecondaryColor");
3021 } else {
3022 sprintf(destination, "IN[%u]", i);
3023 }
3024
3025 if (size == 1) {
3026 shader_addline(buffer, "%s.%s = 0.0;\n", destination, reg_mask);
3027 } else {
3028 shader_addline(buffer, "%s.%s = vec%u(0.0);\n", destination, reg_mask, size);
3029 }
3030 }
3031 }
3032
3033 HeapFree(GetProcessHeap(), 0, set);
3034 }
3035
3036 static GLhandleARB generate_param_reorder_function(IWineD3DVertexShader *vertexshader,
3037 IWineD3DPixelShader *pixelshader,
3038 WineD3D_GL_Info *gl_info) {
3039 GLhandleARB ret = 0;
3040 IWineD3DVertexShaderImpl *vs = (IWineD3DVertexShaderImpl *) vertexshader;
3041 IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *) pixelshader;
3042 IWineD3DDeviceImpl *device;
3043 DWORD vs_major = vs ? WINED3DSHADER_VERSION_MAJOR(vs->baseShader.hex_version) : 0;
3044 DWORD ps_major = ps ? WINED3DSHADER_VERSION_MAJOR(ps->baseShader.hex_version) : 0;
3045 unsigned int i;
3046 SHADER_BUFFER buffer;
3047 DWORD usage_token;
3048 DWORD register_token;
3049 DWORD usage, usage_idx, writemask;
3050 char reg_mask[6];
3051 semantic *semantics_out, *semantics_in;
3052
3053 buffer.buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, SHADER_PGMSIZE);
3054 buffer.bsize = 0;
3055 buffer.lineNo = 0;
3056 buffer.newline = TRUE;
3057
3058 shader_addline(&buffer, "#version 120\n");
3059
3060 if(vs_major < 3 && ps_major < 3) {
3061 /* That one is easy: The vertex shader writes to the builtin varyings, the pixel shader reads from them.
3062 * Take care about the texcoord .w fixup though if we're using the fixed function fragment pipeline
3063 */
3064 device = (IWineD3DDeviceImpl *) vs->baseShader.device;
3065 if((GLINFO_LOCATION).set_texcoord_w && ps_major == 0 && vs_major > 0 &&
3066 !device->frag_pipe->ffp_proj_control) {
3067 shader_addline(&buffer, "void order_ps_input() {\n");
3068 for(i = 0; i < min(8, MAX_REG_TEXCRD); i++) {
3069 if(vs->baseShader.reg_maps.texcoord_mask[i] != 0 &&
3070 vs->baseShader.reg_maps.texcoord_mask[i] != WINED3DSP_WRITEMASK_ALL) {
3071 shader_addline(&buffer, "gl_TexCoord[%u].w = 1.0;\n", i);
3072 }
3073 }
3074 shader_addline(&buffer, "}\n");
3075 } else {
3076 shader_addline(&buffer, "void order_ps_input() { /* do nothing */ }\n");
3077 }
3078 } else if(ps_major < 3 && vs_major >= 3) {
3079 /* The vertex shader writes to its own varyings, the pixel shader needs them in the builtin ones */
3080 semantics_out = vs->semantics_out;
3081
3082 shader_addline(&buffer, "void order_ps_input(in vec4 OUT[%u]) {\n", MAX_REG_OUTPUT);
3083 for(i = 0; i < MAX_REG_OUTPUT; i++) {
3084 usage_token = semantics_out[i].usage;
3085 if (!usage_token) continue;
3086 register_token = semantics_out[i].reg;
3087
3088 usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
3089 usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
3090 writemask = shader_glsl_get_write_mask(register_token, reg_mask);
3091
3092 switch(usage) {
3093 case WINED3DDECLUSAGE_COLOR:
3094 if (usage_idx == 0)
3095 shader_addline(&buffer, "gl_FrontColor%s = OUT[%u]%s;\n", reg_mask, i, reg_mask);
3096 else if (usage_idx == 1)
3097 shader_addline(&buffer, "gl_FrontSecondaryColor%s = OUT[%u]%s;\n", reg_mask, i, reg_mask);
3098 break;
3099
3100 case WINED3DDECLUSAGE_POSITION:
3101 shader_addline(&buffer, "gl_Position%s = OUT[%u]%s;\n", reg_mask, i, reg_mask);
3102 break;
3103
3104 case WINED3DDECLUSAGE_TEXCOORD:
3105 if (usage_idx < 8) {
3106 if(!(GLINFO_LOCATION).set_texcoord_w || ps_major > 0) writemask |= WINED3DSP_WRITEMASK_3;
3107
3108 shader_addline(&buffer, "gl_TexCoord[%u]%s = OUT[%u]%s;\n",
3109 usage_idx, reg_mask, i, reg_mask);
3110 if(!(writemask & WINED3DSP_WRITEMASK_3)) {
3111 shader_addline(&buffer, "gl_TexCoord[%u].w = 1.0;\n", usage_idx);
3112 }
3113 }
3114 break;
3115
3116 case WINED3DDECLUSAGE_PSIZE:
3117 shader_addline(&buffer, "gl_PointSize = OUT[%u].x;\n", i);
3118 break;
3119
3120 case WINED3DDECLUSAGE_FOG:
3121 shader_addline(&buffer, "gl_FogFragCoord = OUT[%u].%c;\n", i, reg_mask[1]);
3122 break;
3123
3124 default:
3125 break;
3126 }
3127 }
3128 shader_addline(&buffer, "}\n");
3129
3130 } else if(ps_major >= 3 && vs_major >= 3) {
3131 semantics_out = vs->semantics_out;
3132 semantics_in = ps->semantics_in;
3133
3134 /* This one is tricky: a 3.0 pixel shader reads from a 3.0 vertex shader */
3135 shader_addline(&buffer, "varying vec4 IN[%u];\n", GL_LIMITS(glsl_varyings) / 4);
3136 shader_addline(&buffer, "void order_ps_input(in vec4 OUT[%u]) {\n", MAX_REG_OUTPUT);
3137
3138 /* First, sort out position and point size. Those are not passed to the pixel shader */
3139 for(i = 0; i < MAX_REG_OUTPUT; i++) {
3140 usage_token = semantics_out[i].usage;
3141 if (!usage_token) continue;
3142 register_token = semantics_out[i].reg;
3143
3144 usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
3145 usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
3146 shader_glsl_get_write_mask(register_token, reg_mask);
3147
3148 switch(usage) {
3149 case WINED3DDECLUSAGE_POSITION:
3150 shader_addline(&buffer, "gl_Position%s = OUT[%u]%s;\n", reg_mask, i, reg_mask);
3151 break;
3152
3153 case WINED3DDECLUSAGE_PSIZE:
3154 shader_addline(&buffer, "gl_PointSize = OUT[%u].x;\n", i);
3155 break;
3156
3157 default:
3158 break;
3159 }
3160 }
3161
3162 /* Then, fix the pixel shader input */
3163 handle_ps3_input(&buffer, semantics_in, semantics_out, gl_info, ps->input_reg_map);
3164
3165 shader_addline(&buffer, "}\n");
3166 } else if(ps_major >= 3 && vs_major < 3) {
3167 semantics_in = ps->semantics_in;
3168
3169 shader_addline(&buffer, "varying vec4 IN[%u];\n", GL_LIMITS(glsl_varyings) / 4);
3170 shader_addline(&buffer, "void order_ps_input() {\n");
3171 /* The vertex shader wrote to the builtin varyings. There is no need to figure out position and
3172 * point size, but we depend on the optimizers kindness to find out that the pixel shader doesn't
3173 * read gl_TexCoord and gl_ColorX, otherwise we'll run out of varyings
3174 */
3175 handle_ps3_input(&buffer, semantics_in, NULL, gl_info, ps->input_reg_map);
3176 shader_addline(&buffer, "}\n");
3177 } else {
3178 ERR("Unexpected vertex and pixel shader version condition: vs: %d, ps: %d\n", vs_major, ps_major);
3179 }
3180
3181 ret = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
3182 checkGLcall("glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB)");
3183 GL_EXTCALL(glShaderSourceARB(ret, 1, (const char**)&buffer.buffer, NULL));
3184 checkGLcall("glShaderSourceARB(ret, 1, (const char**)&buffer.buffer, NULL)");
3185 GL_EXTCALL(glCompileShaderARB(ret));
3186 checkGLcall("glCompileShaderARB(ret)");
3187
3188 HeapFree(GetProcessHeap(), 0, buffer.buffer);
3189 return ret;
3190 }
3191
3192 static void hardcode_local_constants(IWineD3DBaseShaderImpl *shader, WineD3D_GL_Info *gl_info, GLhandleARB programId, char prefix) {
3193 local_constant* lconst;
3194 GLuint tmp_loc;
3195 float *value;
3196 char glsl_name[8];
3197
3198 LIST_FOR_EACH_ENTRY(lconst, &shader->baseShader.constantsF, local_constant, entry) {
3199 value = (float *) lconst->value;
3200 snprintf(glsl_name, sizeof(glsl_name), "%cLC%u", prefix, lconst->idx);
3201 tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
3202 GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, value));
3203 }
3204 checkGLcall("Hardcoding local constants\n");
3205 }
3206
3207 /** Sets the GLSL program ID for the given pixel and vertex shader combination.
3208 * It sets the programId on the current StateBlock (because it should be called
3209 * inside of the DrawPrimitive() part of the render loop).
3210 *
3211 * If a program for the given combination does not exist, create one, and store
3212 * the program in the hash table. If it creates a program, it will link the
3213 * given objects, too.
3214 */
3215 static void set_glsl_shader_program(IWineD3DDevice *iface, BOOL use_ps, BOOL use_vs) {
3216 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3217 struct shader_glsl_priv *priv = (struct shader_glsl_priv *)This->shader_priv;
3218 WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
3219 IWineD3DPixelShader *pshader = This->stateBlock->pixelShader;
3220 IWineD3DVertexShader *vshader = This->stateBlock->vertexShader;
3221 struct glsl_shader_prog_link *entry = NULL;
3222 GLhandleARB programId = 0;
3223 GLhandleARB reorder_shader_id = 0;
3224 int i;
3225 char glsl_name[8];
3226
3227 GLhandleARB vshader_id = use_vs ? ((IWineD3DBaseShaderImpl*)vshader)->baseShader.prgId : 0;
3228 GLhandleARB pshader_id = use_ps ? ((IWineD3DBaseShaderImpl*)pshader)->baseShader.prgId : 0;
3229 entry = get_glsl_program_entry(priv, vshader_id, pshader_id);
3230 if (entry) {
3231 priv->glsl_program = entry;
3232 return;
3233 }
3234
3235 /* If we get to this point, then no matching program exists, so we create one */
3236 programId = GL_EXTCALL(glCreateProgramObjectARB());
3237 TRACE("Created new GLSL shader program %u\n", programId);
3238
3239 /* Create the entry */
3240 entry = HeapAlloc(GetProcessHeap(), 0, sizeof(struct glsl_shader_prog_link));
3241 entry->programId = programId;
3242 entry->vshader = vshader_id;
3243 entry->pshader = pshader_id;
3244 /* Add the hash table entry */
3245 add_glsl_program_entry(priv, entry);
3246
3247 /* Set the current program */
3248 priv->glsl_program = entry;
3249
3250 /* Attach GLSL vshader */
3251 if (vshader_id) {
3252 int max_attribs = 16; /* TODO: Will this always be the case? It is at the moment... */
3253 char tmp_name[10];
3254
3255 reorder_shader_id = generate_param_reorder_function(vshader, pshader, gl_info);
3256 TRACE("Attaching GLSL shader object %u to program %u\n", reorder_shader_id, programId);
3257 GL_EXTCALL(glAttachObjectARB(programId, reorder_shader_id));
3258 checkGLcall("glAttachObjectARB");
3259 /* Flag the reorder function for deletion, then it will be freed automatically when the program
3260 * is destroyed
3261 */
3262 GL_EXTCALL(glDeleteObjectARB(reorder_shader_id));
3263
3264 TRACE("Attaching GLSL shader object %u to program %u\n", vshader_id, programId);
3265 GL_EXTCALL(glAttachObjectARB(programId, vshader_id));
3266 checkGLcall("glAttachObjectARB");
3267
3268 /* Bind vertex attributes to a corresponding index number to match
3269 * the same index numbers as ARB_vertex_programs (makes loading
3270 * vertex attributes simpler). With this method, we can use the
3271 * exact same code to load the attributes later for both ARB and
3272 * GLSL shaders.
3273 *
3274 * We have to do this here because we need to know the Program ID
3275 * in order to make the bindings work, and it has to be done prior
3276 * to linking the GLSL program. */
3277 for (i = 0; i < max_attribs; ++i) {
3278 if (((IWineD3DBaseShaderImpl*)vshader)->baseShader.reg_maps.attributes[i]) {
3279 snprintf(tmp_name, sizeof(tmp_name), "attrib%i", i);
3280 GL_EXTCALL(glBindAttribLocationARB(programId, i, tmp_name));
3281 }
3282 }
3283 checkGLcall("glBindAttribLocationARB");
3284
3285 list_add_head(&((IWineD3DBaseShaderImpl *)vshader)->baseShader.linked_programs, &entry->vshader_entry);
3286 }
3287
3288 /* Attach GLSL pshader */
3289 if (pshader_id) {
3290 TRACE("Attaching GLSL shader object %u to program %u\n", pshader_id, programId);
3291 GL_EXTCALL(glAttachObjectARB(programId, pshader_id));
3292 checkGLcall("glAttachObjectARB");
3293
3294 list_add_head(&((IWineD3DBaseShaderImpl *)pshader)->baseShader.linked_programs, &entry->pshader_entry);
3295 }
3296
3297 /* Link the program */
3298 TRACE("Linking GLSL shader program %u\n", programId);
3299 GL_EXTCALL(glLinkProgramARB(programId));
3300 print_glsl_info_log(&GLINFO_LOCATION, programId);
3301
3302 entry->vuniformF_locations = HeapAlloc(GetProcessHeap(), 0, sizeof(GLhandleARB) * GL_LIMITS(vshader_constantsF));
3303 for (i = 0; i < GL_LIMITS(vshader_constantsF); ++i) {
3304 snprintf(glsl_name, sizeof(glsl_name), "VC[%i]", i);
3305 entry->vuniformF_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
3306 }
3307 for (i = 0; i < MAX_CONST_I; ++i) {
3308 snprintf(glsl_name, sizeof(glsl_name), "VI[%i]", i);
3309 entry->vuniformI_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
3310 }
3311 entry->puniformF_locations = HeapAlloc(GetProcessHeap(), 0, sizeof(GLhandleARB) * GL_LIMITS(pshader_constantsF));
3312 for (i = 0; i < GL_LIMITS(pshader_constantsF); ++i) {
3313 snprintf(glsl_name, sizeof(glsl_name), "PC[%i]", i);
3314 entry->puniformF_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
3315 }
3316 for (i = 0; i < MAX_CONST_I; ++i) {
3317 snprintf(glsl_name, sizeof(glsl_name), "PI[%i]", i);
3318 entry->puniformI_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
3319 }
3320
3321 if(pshader) {
3322 for(i = 0; i < ((IWineD3DPixelShaderImpl*)pshader)->numbumpenvmatconsts; i++) {
3323 char name[32];
3324 sprintf(name, "bumpenvmat%d", ((IWineD3DPixelShaderImpl*)pshader)->bumpenvmatconst[i].texunit);
3325 entry->bumpenvmat_location[i] = GL_EXTCALL(glGetUniformLocationARB(programId, name));
3326 sprintf(name, "luminancescale%d", ((IWineD3DPixelShaderImpl*)pshader)->luminanceconst[i].texunit);
3327 entry->luminancescale_location[i] = GL_EXTCALL(glGetUniformLocationARB(programId, name));
3328 sprintf(name, "luminanceoffset%d", ((IWineD3DPixelShaderImpl*)pshader)->luminanceconst[i].texunit);
3329 entry->luminanceoffset_location[i] = GL_EXTCALL(glGetUniformLocationARB(programId, name));
3330 }
3331 }
3332
3333
3334 entry->posFixup_location = GL_EXTCALL(glGetUniformLocationARB(programId, "posFixup"));
3335 entry->srgb_comparison_location = GL_EXTCALL(glGetUniformLocationARB(programId, "srgb_comparison"));
3336 entry->srgb_mul_low_location = GL_EXTCALL(glGetUniformLocationARB(programId, "srgb_mul_low"));
3337 entry->ycorrection_location = GL_EXTCALL(glGetUniformLocationARB(programId, "ycorrection"));
3338 checkGLcall("Find glsl program uniform locations");
3339
3340 if (pshader && WINED3DSHADER_VERSION_MAJOR(((IWineD3DPixelShaderImpl *)pshader)->baseShader.hex_version) >= 3
3341 && ((IWineD3DPixelShaderImpl *)pshader)->declared_in_count > GL_LIMITS(glsl_varyings) / 4) {
3342 TRACE("Shader %d needs vertex color clamping disabled\n", programId);
3343 entry->vertex_color_clamp = GL_FALSE;
3344 } else {
3345 entry->vertex_color_clamp = GL_FIXED_ONLY_ARB;
3346 }
3347
3348 /* Set the shader to allow uniform loading on it */
3349 GL_EXTCALL(glUseProgramObjectARB(programId));
3350 checkGLcall("glUseProgramObjectARB(programId)");
3351
3352 /* Load the vertex and pixel samplers now. The function that finds the mappings makes sure
3353 * that it stays the same for each vertexshader-pixelshader pair(=linked glsl program). If
3354 * a pshader with fixed function pipeline is used there are no vertex samplers, and if a
3355 * vertex shader with fixed function pixel processing is used we make sure that the card
3356 * supports enough samplers to allow the max number of vertex samplers with all possible
3357 * fixed function fragment processing setups. So once the program is linked these samplers
3358 * won't change.
3359 */
3360 if(vshader_id) {
3361 /* Load vertex shader samplers */
3362 shader_glsl_load_vsamplers(gl_info, (IWineD3DStateBlock*)This->stateBlock, programId);
3363 }
3364 if(pshader_id) {
3365 /* Load pixel shader samplers */
3366 shader_glsl_load_psamplers(gl_info, (IWineD3DStateBlock*)This->stateBlock, programId);
3367 }
3368
3369 /* If the local constants do not have to be loaded with the environment constants,
3370 * load them now to have them hardcoded in the GLSL program. This saves some CPU cycles
3371 * later
3372 */
3373 if(pshader && !((IWineD3DPixelShaderImpl*)pshader)->baseShader.load_local_constsF) {
3374 hardcode_local_constants((IWineD3DBaseShaderImpl *) pshader, gl_info, programId, 'P');
3375 }
3376 if(vshader && !((IWineD3DVertexShaderImpl*)vshader)->baseShader.load_local_constsF) {
3377 hardcode_local_constants((IWineD3DBaseShaderImpl *) vshader, gl_info, programId, 'V');
3378 }
3379 }
3380
3381 static GLhandleARB create_glsl_blt_shader(WineD3D_GL_Info *gl_info) {
3382 GLhandleARB program_id;
3383 GLhandleARB vshader_id, pshader_id;
3384 const char *blt_vshader[] = {
3385 "#version 120\n"
3386 "void main(void)\n"
3387 "{\n"
3388 " gl_Position = gl_Vertex;\n"
3389 " gl_FrontColor = vec4(1.0);\n"
3390 " gl_TexCoord[0].x = (gl_Vertex.x * 0.5) + 0.5;\n"
3391 " gl_TexCoord[0].y = (-gl_Vertex.y * 0.5) + 0.5;\n"
3392 "}\n"
3393 };
3394
3395 const char *blt_pshader[] = {
3396 "#version 120\n"
3397 "uniform sampler2D sampler;\n"
3398 "void main(void)\n"
3399 "{\n"
3400 " gl_FragDepth = texture2D(sampler, gl_TexCoord[0].xy).x;\n"
3401 "}\n"
3402 };
3403
3404 vshader_id = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
3405 GL_EXTCALL(glShaderSourceARB(vshader_id, 1, blt_vshader, NULL));
3406 GL_EXTCALL(glCompileShaderARB(vshader_id));
3407
3408 pshader_id = GL_EXTCALL(glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB));
3409 GL_EXTCALL(glShaderSourceARB(pshader_id, 1, blt_pshader, NULL));
3410 GL_EXTCALL(glCompileShaderARB(pshader_id));
3411
3412 program_id = GL_EXTCALL(glCreateProgramObjectARB());
3413 GL_EXTCALL(glAttachObjectARB(program_id, vshader_id));
3414 GL_EXTCALL(glAttachObjectARB(program_id, pshader_id));
3415 GL_EXTCALL(glLinkProgramARB(program_id));
3416
3417 print_glsl_info_log(&GLINFO_LOCATION, program_id);
3418
3419 /* Once linked we can mark the shaders for deletion. They will be deleted once the program
3420 * is destroyed
3421 */
3422 GL_EXTCALL(glDeleteObjectARB(vshader_id));
3423 GL_EXTCALL(glDeleteObjectARB(pshader_id));
3424 return program_id;
3425 }
3426
3427 static void shader_glsl_select(IWineD3DDevice *iface, BOOL usePS, BOOL useVS) {
3428 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3429 struct shader_glsl_priv *priv = (struct shader_glsl_priv *)This->shader_priv;
3430 WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
3431 GLhandleARB program_id = 0;
3432 GLenum old_vertex_color_clamp, current_vertex_color_clamp;
3433
3434 old_vertex_color_clamp = priv->glsl_program ? priv->glsl_program->vertex_color_clamp : GL_FIXED_ONLY_ARB;
3435
3436 if (useVS || usePS) set_glsl_shader_program(iface, usePS, useVS);
3437 else priv->glsl_program = NULL;
3438
3439 current_vertex_color_clamp = priv->glsl_program ? priv->glsl_program->vertex_color_clamp : GL_FIXED_ONLY_ARB;
3440
3441 if (old_vertex_color_clamp != current_vertex_color_clamp) {
3442 if (GL_SUPPORT(ARB_COLOR_BUFFER_FLOAT)) {
3443 GL_EXTCALL(glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, current_vertex_color_clamp));
3444 checkGLcall("glClampColorARB");
3445 } else {
3446 FIXME("vertex color clamp needs to be changed, but extension not supported.\n");
3447 }
3448 }
3449
3450 program_id = priv->glsl_program ? priv->glsl_program->programId : 0;
3451 if (program_id) TRACE("Using GLSL program %u\n", program_id);
3452 GL_EXTCALL(glUseProgramObjectARB(program_id));
3453 checkGLcall("glUseProgramObjectARB");
3454 }
3455
3456 static void shader_glsl_select_depth_blt(IWineD3DDevice *iface) {
3457 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3458 WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
3459 struct shader_glsl_priv *priv = (struct shader_glsl_priv *) This->shader_priv;
3460 static GLhandleARB loc = -1;
3461
3462 if (!priv->depth_blt_glsl_program_id) {
3463 priv->depth_blt_glsl_program_id = create_glsl_blt_shader(gl_info);
3464 loc = GL_EXTCALL(glGetUniformLocationARB(priv->depth_blt_glsl_program_id, "sampler"));
3465 }
3466
3467 GL_EXTCALL(glUseProgramObjectARB(priv->depth_blt_glsl_program_id));
3468 GL_EXTCALL(glUniform1iARB(loc, 0));
3469 }
3470
3471 static void shader_glsl_deselect_depth_blt(IWineD3DDevice *iface) {
3472 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3473 WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
3474 struct shader_glsl_priv *priv = (struct shader_glsl_priv *) This->shader_priv;
3475 GLhandleARB program_id;
3476
3477 program_id = priv->glsl_program ? priv->glsl_program->programId : 0;
3478 if (program_id) TRACE("Using GLSL program %u\n", program_id);
3479
3480 GL_EXTCALL(glUseProgramObjectARB(program_id));
3481 checkGLcall("glUseProgramObjectARB");
3482 }
3483
3484 static void shader_glsl_cleanup(IWineD3DDevice *iface) {
3485 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3486 WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
3487 GL_EXTCALL(glUseProgramObjectARB(0));
3488 }
3489
3490 static void shader_glsl_destroy(IWineD3DBaseShader *iface) {
3491 struct list *linked_programs;
3492 IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *) iface;
3493 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *)This->baseShader.device;
3494 struct shader_glsl_priv *priv = (struct shader_glsl_priv *)device->shader_priv;
3495 WineD3D_GL_Info *gl_info = &device->adapter->gl_info;
3496
3497 /* Note: Do not use QueryInterface here to find out which shader type this is because this code
3498 * can be called from IWineD3DBaseShader::Release
3499 */
3500 char pshader = shader_is_pshader_version(This->baseShader.hex_version);
3501
3502 if(This->baseShader.prgId == 0) return;
3503 linked_programs = &This->baseShader.linked_programs;
3504
3505 TRACE("Deleting linked programs\n");
3506 if (linked_programs->next) {
3507 struct glsl_shader_prog_link *entry, *entry2;
3508
3509 if(pshader) {
3510 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs, struct glsl_shader_prog_link, pshader_entry) {
3511 delete_glsl_program_entry(priv, gl_info, entry);
3512 }
3513 } else {
3514 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs, struct glsl_shader_prog_link, vshader_entry) {
3515 delete_glsl_program_entry(priv, gl_info, entry);
3516 }
3517 }
3518 }
3519
3520 TRACE("Deleting shader object %u\n", This->baseShader.prgId);
3521 GL_EXTCALL(glDeleteObjectARB(This->baseShader.prgId));
3522 checkGLcall("glDeleteObjectARB");
3523 This->baseShader.prgId = 0;
3524 This->baseShader.is_compiled = FALSE;
3525 }
3526
3527 static unsigned int glsl_program_key_hash(void *key) {
3528 glsl_program_key_t *k = (glsl_program_key_t *)key;
3529
3530 unsigned int hash = k->vshader | k->pshader << 16;
3531 hash += ~(hash << 15);
3532 hash ^= (hash >> 10);
3533 hash += (hash << 3);
3534 hash ^= (hash >> 6);
3535 hash += ~(hash << 11);
3536 hash ^= (hash >> 16);
3537
3538 return hash;
3539 }
3540
3541 static BOOL glsl_program_key_compare(void *keya, void *keyb) {
3542 glsl_program_key_t *ka = (glsl_program_key_t *)keya;
3543 glsl_program_key_t *kb = (glsl_program_key_t *)keyb;
3544
3545 return ka->vshader == kb->vshader && ka->pshader == kb->pshader;
3546 }
3547
3548 static HRESULT shader_glsl_alloc(IWineD3DDevice *iface) {
3549 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3550 struct shader_glsl_priv *priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct shader_glsl_priv));
3551 priv->glsl_program_lookup = hash_table_create(glsl_program_key_hash, glsl_program_key_compare);
3552 This->shader_priv = priv;
3553 return WINED3D_OK;
3554 }
3555
3556 static void shader_glsl_free(IWineD3DDevice *iface) {
3557 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3558 WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
3559 struct shader_glsl_priv *priv = (struct shader_glsl_priv *)This->shader_priv;
3560
3561 if(priv->depth_blt_glsl_program_id) {
3562 GL_EXTCALL(glDeleteObjectARB(priv->depth_blt_glsl_program_id));
3563 }
3564
3565 hash_table_destroy(priv->glsl_program_lookup, NULL, NULL);
3566
3567 HeapFree(GetProcessHeap(), 0, This->shader_priv);
3568 This->shader_priv = NULL;
3569 }
3570
3571 static BOOL shader_glsl_dirty_const(IWineD3DDevice *iface) {
3572 /* TODO: GL_EXT_bindable_uniform can be used to share constants across shaders */
3573 return FALSE;
3574 }
3575
3576 static void shader_glsl_generate_pshader(IWineD3DPixelShader *iface, SHADER_BUFFER *buffer) {
3577 IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)iface;
3578 shader_reg_maps* reg_maps = &This->baseShader.reg_maps;
3579 CONST DWORD *function = This->baseShader.function;
3580 const char *fragcolor;
3581 WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *)This->baseShader.device)->adapter->gl_info;
3582
3583 /* Create the hw GLSL shader object and assign it as the baseShader.prgId */
3584 GLhandleARB shader_obj = GL_EXTCALL(glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB));
3585
3586 shader_addline(buffer, "#version 120\n");
3587
3588 if (GL_SUPPORT(ARB_DRAW_BUFFERS)) {
3589 shader_addline(buffer, "#extension GL_ARB_draw_buffers : enable\n");
3590 }
3591 if (GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
3592 /* The spec says that it doesn't have to be explicitly enabled, but the nvidia
3593 * drivers write a warning if we don't do so
3594 */
3595 shader_addline(buffer, "#extension GL_ARB_texture_rectangle : enable\n");
3596 }
3597
3598 /* Base Declarations */
3599 shader_generate_glsl_declarations( (IWineD3DBaseShader*) This, reg_maps, buffer, &GLINFO_LOCATION);
3600
3601 /* Pack 3.0 inputs */
3602 if (This->baseShader.hex_version >= WINED3DPS_VERSION(3,0)) {
3603
3604 if(((IWineD3DDeviceImpl *) This->baseShader.device)->strided_streams.u.s.position_transformed) {
3605 This->vertexprocessing = pretransformed;
3606 pshader_glsl_input_pack(buffer, This->semantics_in, iface);
3607 } else if(!use_vs((IWineD3DDeviceImpl *) This->baseShader.device)) {
3608 This->vertexprocessing = fixedfunction;
3609 pshader_glsl_input_pack(buffer, This->semantics_in, iface);
3610 } else {
3611 This->vertexprocessing = vertexshader;
3612 }
3613 }
3614
3615 /* Base Shader Body */
3616 shader_generate_main( (IWineD3DBaseShader*) This, buffer, reg_maps, function);
3617
3618 /* Pixel shaders < 2.0 place the resulting color in R0 implicitly */
3619 if (This->baseShader.hex_version < WINED3DPS_VERSION(2,0)) {
3620 /* Some older cards like GeforceFX ones don't support multiple buffers, so also not gl_FragData */
3621 if(GL_SUPPORT(ARB_DRAW_BUFFERS))
3622 shader_addline(buffer, "gl_FragData[0] = R0;\n");
3623 else
3624 shader_addline(buffer, "gl_FragColor = R0;\n");
3625 }
3626
3627 if(GL_SUPPORT(ARB_DRAW_BUFFERS)) {
3628 fragcolor = "gl_FragData[0]";
3629 } else {
3630 fragcolor = "gl_FragColor";
3631 }
3632 if(This->srgb_enabled) {
3633 shader_addline(buffer, "tmp0.xyz = pow(%s.xyz, vec3(%f, %f, %f)) * vec3(%f, %f, %f) - vec3(%f, %f, %f);\n",
3634 fragcolor, srgb_pow, srgb_pow, srgb_pow, srgb_mul_high, srgb_mul_high, srgb_mul_high,
3635 srgb_sub_high, srgb_sub_high, srgb_sub_high);
3636 shader_addline(buffer, "tmp1.xyz = %s.xyz * srgb_mul_low.xyz;\n", fragcolor);
3637 shader_addline(buffer, "%s.x = %s.x < srgb_comparison.x ? tmp1.x : tmp0.x;\n", fragcolor, fragcolor);
3638 shader_addline(buffer, "%s.y = %s.y < srgb_comparison.y ? tmp1.y : tmp0.y;\n", fragcolor, fragcolor);
3639 shader_addline(buffer, "%s.z = %s.z < srgb_comparison.z ? tmp1.z : tmp0.z;\n", fragcolor, fragcolor);
3640 shader_addline(buffer, "%s = clamp(%s, 0.0, 1.0);\n", fragcolor, fragcolor);
3641 }
3642 /* Pixel shader < 3.0 do not replace the fog stage.
3643 * This implements linear fog computation and blending.
3644 * TODO: non linear fog
3645 * NOTE: gl_Fog.start and gl_Fog.end don't hold fog start s and end e but
3646 * -1/(e-s) and e/(e-s) respectively.
3647 */
3648 if(This->baseShader.hex_version < WINED3DPS_VERSION(3,0)) {
3649 shader_addline(buffer, "float Fog = clamp(gl_FogFragCoord * gl_Fog.start + gl_Fog.end, 0.0, 1.0);\n");
3650 shader_addline(buffer, "%s.xyz = mix(gl_Fog.color.xyz, %s.xyz, Fog);\n", fragcolor, fragcolor);
3651 }
3652
3653 shader_addline(buffer, "}\n");
3654
3655 TRACE("Compiling shader object %u\n", shader_obj);
3656 GL_EXTCALL(glShaderSourceARB(shader_obj, 1, (const char**)&buffer->buffer, NULL));
3657 GL_EXTCALL(glCompileShaderARB(shader_obj));
3658 print_glsl_info_log(&GLINFO_LOCATION, shader_obj);
3659
3660 /* Store the shader object */
3661 This->baseShader.prgId = shader_obj;
3662 }
3663
3664 static void shader_glsl_generate_vshader(IWineD3DVertexShader *iface, SHADER_BUFFER *buffer) {
3665 IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
3666 shader_reg_maps* reg_maps = &This->baseShader.reg_maps;
3667 CONST DWORD *function = This->baseShader.function;
3668 WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *)This->baseShader.device)->adapter->gl_info;
3669
3670 /* Create the hw GLSL shader program and assign it as the baseShader.prgId */
3671 GLhandleARB shader_obj = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
3672
3673 shader_addline(buffer, "#version 120\n");
3674
3675 /* Base Declarations */
3676 shader_generate_glsl_declarations( (IWineD3DBaseShader*) This, reg_maps, buffer, &GLINFO_LOCATION);
3677
3678 /* Base Shader Body */
3679 shader_generate_main( (IWineD3DBaseShader*) This, buffer, reg_maps, function);
3680
3681 /* Unpack 3.0 outputs */
3682 if (This->baseShader.hex_version >= WINED3DVS_VERSION(3,0)) {
3683 shader_addline(buffer, "order_ps_input(OUT);\n");
3684 } else {
3685 shader_addline(buffer, "order_ps_input();\n");
3686 }
3687
3688 /* If this shader doesn't use fog copy the z coord to the fog coord so that we can use table fog */
3689 if (!reg_maps->fog)
3690 shader_addline(buffer, "gl_FogFragCoord = gl_Position.z;\n");
3691
3692 /* Write the final position.
3693 *
3694 * OpenGL coordinates specify the center of the pixel while d3d coords specify
3695 * the corner. The offsets are stored in z and w in posFixup. posFixup.y contains
3696 * 1.0 or -1.0 to turn the rendering upside down for offscreen rendering. PosFixup.x
3697 * contains 1.0 to allow a mad.
3698 */
3699 shader_addline(buffer, "gl_Position.y = gl_Position.y * posFixup.y;\n");
3700 shader_addline(buffer, "gl_Position.xy += posFixup.zw * gl_Position.ww;\n");
3701
3702 /* Z coord [0;1]->[-1;1] mapping, see comment in transform_projection in state.c
3703 *
3704 * Basically we want (in homogeneous coordinates) z = z * 2 - 1. However, shaders are run
3705 * before the homogeneous divide, so we have to take the w into account: z = ((z / w) * 2 - 1) * w,
3706 * which is the same as z = z * 2 - w.
3707 */
3708 shader_addline(buffer, "gl_Position.z = gl_Position.z * 2.0 - gl_Position.w;\n");
3709
3710 shader_addline(buffer, "}\n");
3711
3712 TRACE("Compiling shader object %u\n", shader_obj);
3713 GL_EXTCALL(glShaderSourceARB(shader_obj, 1, (const char**)&buffer->buffer, NULL));
3714 GL_EXTCALL(glCompileShaderARB(shader_obj));
3715 print_glsl_info_log(&GLINFO_LOCATION, shader_obj);
3716
3717 /* Store the shader object */
3718 This->baseShader.prgId = shader_obj;
3719 }
3720
3721 static void shader_glsl_get_caps(WINED3DDEVTYPE devtype, WineD3D_GL_Info *gl_info, struct shader_caps *pCaps) {
3722 /* Nvidia Geforce6/7 or Ati R4xx/R5xx cards with GLSL support, support VS 3.0 but older Nvidia/Ati
3723 * models with GLSL support only support 2.0. In case of nvidia we can detect VS 2.0 support using
3724 * vs_nv_version which is based on NV_vertex_program.
3725 * For Ati cards there's no way using glsl (it abstracts the lowlevel info away) and also not
3726 * using ARB_vertex_program. It is safe to assume that when a card supports pixel shader 2.0 it
3727 * supports vertex shader 2.0 too and the way around. We can detect ps2.0 using the maximum number
3728 * of native instructions, so use that here. For more info see the pixel shader versioning code below.
3729 */
3730 if((GLINFO_LOCATION.vs_nv_version == VS_VERSION_20) || (GLINFO_LOCATION.ps_arb_max_instructions <= 512))
3731 pCaps->VertexShaderVersion = WINED3DVS_VERSION(2,0);
3732 else
3733 pCaps->VertexShaderVersion = WINED3DVS_VERSION(3,0);
3734 TRACE_(d3d_caps)("Hardware vertex shader version %d.%d enabled (GLSL)\n", (pCaps->VertexShaderVersion >> 8) & 0xff, pCaps->VertexShaderVersion & 0xff);
3735 pCaps->MaxVertexShaderConst = GL_LIMITS(vshader_constantsF);
3736
3737 /* Older DX9-class videocards (GeforceFX / Radeon >9500/X*00) only support pixel shader 2.0/2.0a/2.0b.
3738 * In OpenGL the extensions related to GLSL abstract lowlevel GL info away which is needed
3739 * to distinguish between 2.0 and 3.0 (and 2.0a/2.0b). In case of Nvidia we use their fragment
3740 * program extensions. On other hardware including ATI GL_ARB_fragment_program offers the info
3741 * in max native instructions. Intel and others also offer the info in this extension but they
3742 * don't support GLSL (at least on Windows).
3743 *
3744 * PS2.0 requires at least 96 instructions, 2.0a/2.0b go up to 512. Assume that if the number
3745 * of instructions is 512 or less we have to do with ps2.0 hardware.
3746 * NOTE: ps3.0 hardware requires 512 or more instructions but ati and nvidia offer 'enough' (1024 vs 4096) on their most basic ps3.0 hardware.
3747 */
3748 if((GLINFO_LOCATION.ps_nv_version == PS_VERSION_20) || (GLINFO_LOCATION.ps_arb_max_instructions <= 512))
3749 pCaps->PixelShaderVersion = WINED3DPS_VERSION(2,0);
3750 else
3751 pCaps->PixelShaderVersion = WINED3DPS_VERSION(3,0);
3752
3753 /* FIXME: The following line is card dependent. -8.0 to 8.0 is the
3754 * Direct3D minimum requirement.
3755 *
3756 * Both GL_ARB_fragment_program and GLSL require a "maximum representable magnitude"
3757 * of colors to be 2^10, and 2^32 for other floats. Should we use 1024 here?
3758 *
3759 * The problem is that the refrast clamps temporary results in the shader to
3760 * [-MaxValue;+MaxValue]. If the card's max value is bigger than the one we advertize here,
3761 * then applications may miss the clamping behavior. On the other hand, if it is smaller,
3762 * the shader will generate incorrect results too. Unfortunately, GL deliberately doesn't
3763 * offer a way to query this.
3764 */
3765 pCaps->PixelShader1xMaxValue = 8.0;
3766 TRACE_(d3d_caps)("Hardware pixel shader version %d.%d enabled (GLSL)\n", (pCaps->PixelShaderVersion >> 8) & 0xff, pCaps->PixelShaderVersion & 0xff);
3767 }
3768
3769 static BOOL shader_glsl_conv_supported(WINED3DFORMAT fmt) {
3770 TRACE("Checking shader format support for format %s:", debug_d3dformat(fmt));
3771 switch(fmt) {
3772 case WINED3DFMT_V8U8:
3773 case WINED3DFMT_V16U16:
3774 case WINED3DFMT_X8L8V8U8:
3775 case WINED3DFMT_L6V5U5:
3776 case WINED3DFMT_Q8W8V8U8:
3777 case WINED3DFMT_ATI2N:
3778 TRACE("[OK]\n");
3779 return TRUE;
3780 default:
3781 TRACE("[FAILED\n");
3782 return FALSE;
3783 }
3784 }
3785
3786 const shader_backend_t glsl_shader_backend = {
3787 shader_glsl_select,
3788 shader_glsl_select_depth_blt,
3789 shader_glsl_deselect_depth_blt,
3790 shader_glsl_load_constants,
3791 shader_glsl_cleanup,
3792 shader_glsl_color_correction,
3793 shader_glsl_destroy,
3794 shader_glsl_alloc,
3795 shader_glsl_free,
3796 shader_glsl_dirty_const,
3797 shader_glsl_generate_pshader,
3798 shader_glsl_generate_vshader,
3799 shader_glsl_get_caps,
3800 shader_glsl_conv_supported,
3801 };