2 * Pixel and vertex shaders implementation using ARB_vertex_program
3 * and ARB_fragment_program GL extensions.
5 * Copyright 2002-2003 Jason Edmeades
6 * Copyright 2002-2003 Raphael Junqueira
7 * Copyright 2004 Christian Costa
8 * Copyright 2005 Oliver Stieber
9 * Copyright 2006 Ivan Gyurdiev
10 * Copyright 2006 Jason Green
11 * Copyright 2006 Henri Verbeet
12 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
13 * Copyright 2009 Henri Verbeet for CodeWeavers
15 * This library is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU Lesser General Public
17 * License as published by the Free Software Foundation; either
18 * version 2.1 of the License, or (at your option) any later version.
20 * This library is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * Lesser General Public License for more details.
25 * You should have received a copy of the GNU Lesser General Public
26 * License along with this library; if not, write to the Free Software
27 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
35 #include "wined3d_private.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
38 WINE_DECLARE_DEBUG_CHANNEL(d3d_constants);
39 WINE_DECLARE_DEBUG_CHANNEL(d3d_caps);
40 WINE_DECLARE_DEBUG_CHANNEL(d3d);
42 #define GLINFO_LOCATION (*gl_info)
44 /* GL locking for state handlers is done by the caller. */
45 static BOOL need_mova_const(IWineD3DBaseShader *shader, const WineD3D_GL_Info *gl_info) {
46 IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *) shader;
47 if(!This->baseShader.reg_maps.usesmova) return FALSE;
48 return !GL_SUPPORT(NV_VERTEX_PROGRAM2_OPTION);
51 static BOOL need_helper_const(const WineD3D_GL_Info *gl_info) {
52 if (!GL_SUPPORT(NV_VERTEX_PROGRAM) /* Need to init colors. */
53 || gl_info->quirks & WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT /* Load the immval offset. */
54 || gl_info->quirks & WINED3D_QUIRK_SET_TEXCOORD_W) /* Have to init texcoords. */
61 static unsigned int reserved_vs_const(IWineD3DBaseShader *shader, const WineD3D_GL_Info *gl_info) {
63 /* We use one PARAM for the pos fixup, and in some cases one to load
64 * some immediate values into the shader
66 if(need_helper_const(gl_info)) ret++;
67 if(need_mova_const(shader, gl_info)) ret++;
71 static inline BOOL ffp_clip_emul(IWineD3DStateBlockImpl *stateblock)
73 return stateblock->lowest_disabled_stage < 7;
76 /* Returns TRUE if result.clip from GL_NV_vertex_program2 should be used and FALSE otherwise */
77 static inline BOOL use_nv_clip(const WineD3D_GL_Info *gl_info)
79 return GL_SUPPORT(NV_VERTEX_PROGRAM2_OPTION);
82 /* Internally used shader constants. Applications can use constants 0 to GL_LIMITS(vshader_constantsF) - 1,
83 * so upload them above that
85 #define ARB_SHADER_PRIVCONST_BASE (GL_LIMITS(vshader_constantsF) - 1)
86 #define ARB_SHADER_PRIVCONST_POS ARB_SHADER_PRIVCONST_BASE + 0
88 /* ARB_program_shader private data */
111 unsigned int loop_no;
114 struct loop_control loop_control;
118 struct arb_ps_np2fixup_info
120 struct ps_np2fixup_info super;
121 /* For ARB we need a offset value:
122 * With both GLSL and ARB mode the NP2 fixup information (the texture dimensions) are stored in a
123 * consecutive way (GLSL uses a uniform array). Since ARB doesn't know the notion of a "standalone"
124 * array we need an offset to the index inside the program local parameter array. */
128 struct arb_ps_compile_args
130 struct ps_compile_args super;
131 DWORD bools; /* WORD is enough, use DWORD for alignment */
132 unsigned char loop_ctrl[MAX_CONST_I][3];
135 struct stb_const_desc
137 unsigned char texunit;
141 struct arb_ps_compiled_shader
143 struct arb_ps_compile_args args;
144 struct arb_ps_np2fixup_info np2fixup_info;
145 struct stb_const_desc bumpenvmatconst[MAX_TEXTURES];
146 struct stb_const_desc luminanceconst[MAX_TEXTURES];
147 UINT int_consts[MAX_CONST_I];
150 unsigned char numbumpenvmatconsts;
154 struct arb_vs_compile_args
156 struct vs_compile_args super;
162 char clip_control[2];
164 DWORD boolclip_compare;
169 unsigned char vertex_samplers[4];
170 DWORD vertex_samplers_compare;
172 unsigned char loop_ctrl[MAX_CONST_I][3];
175 struct arb_vs_compiled_shader
177 struct arb_vs_compile_args args;
179 UINT int_consts[MAX_CONST_I];
181 char need_color_unclamp;
185 struct recorded_instruction
187 struct wined3d_shader_instruction ins;
191 struct shader_arb_ctx_priv
196 /* plain GL_ARB_vertex_program or GL_ARB_fragment_program */
198 /* GL_NV_vertex_progam2_option or GL_NV_fragment_program_option */
200 /* GL_NV_vertex_program3 or GL_NV_fragment_program2 */
204 const struct arb_vs_compile_args *cur_vs_args;
205 const struct arb_ps_compile_args *cur_ps_args;
206 const struct arb_ps_compiled_shader *compiled_fprog;
207 const struct arb_vs_compiled_shader *compiled_vprog;
208 struct arb_ps_np2fixup_info *cur_np2fixup_info;
209 struct list control_frames;
213 unsigned int num_loops, loop_depth, num_ifcs;
216 unsigned int vs_clipplanes;
220 /* For 3.0 vertex shaders */
221 const char *vs_output[MAX_REG_OUTPUT];
222 /* For 2.x and earlier vertex shaders */
223 const char *texcrd_output[8], *color_output[2], *fog_output;
225 /* 3.0 pshader input for compatibility with fixed function */
226 const char *ps_input[MAX_REG_INPUT];
231 struct wined3d_shader_signature_element *sig;
233 struct wine_rb_entry entry;
236 struct arb_pshader_private {
237 struct arb_ps_compiled_shader *gl_shaders;
238 UINT num_gl_shaders, shader_array_size;
239 BOOL has_signature_idx;
240 DWORD input_signature_idx;
241 DWORD clipplane_emulation;
245 struct arb_vshader_private {
246 struct arb_vs_compiled_shader *gl_shaders;
247 UINT num_gl_shaders, shader_array_size;
250 struct shader_arb_priv
252 GLuint current_vprogram_id;
253 GLuint current_fprogram_id;
254 const struct arb_ps_compiled_shader *compiled_fprog;
255 const struct arb_vs_compiled_shader *compiled_vprog;
256 GLuint depth_blt_vprogram_id;
257 GLuint depth_blt_fprogram_id[tex_type_count];
258 BOOL use_arbfp_fixed_func;
259 struct wine_rb_tree fragment_shaders;
260 BOOL last_ps_const_clamped;
261 BOOL last_vs_color_unclamp;
263 struct wine_rb_tree signature_tree;
267 /********************************************************
268 * ARB_[vertex/fragment]_program helper functions follow
269 ********************************************************/
272 * Loads floating point constants into the currently set ARB_vertex/fragment_program.
273 * When constant_list == NULL, it will load all the constants.
275 * @target_type should be either GL_VERTEX_PROGRAM_ARB (for vertex shaders)
276 * or GL_FRAGMENT_PROGRAM_ARB (for pixel shaders)
278 /* GL locking is done by the caller */
279 static unsigned int shader_arb_load_constantsF(IWineD3DBaseShaderImpl* This, const WineD3D_GL_Info *gl_info,
280 GLuint target_type, unsigned int max_constants, const float *constants, char *dirty_consts)
282 local_constant* lconst;
286 if (TRACE_ON(d3d_shader)) {
287 for(i = 0; i < max_constants; i++) {
288 if(!dirty_consts[i]) continue;
289 TRACE_(d3d_constants)("Loading constants %i: %f, %f, %f, %f\n", i,
290 constants[i * 4 + 0], constants[i * 4 + 1],
291 constants[i * 4 + 2], constants[i * 4 + 3]);
294 /* In 1.X pixel shaders constants are implicitly clamped in the range [-1;1] */
295 if (target_type == GL_FRAGMENT_PROGRAM_ARB && This->baseShader.reg_maps.shader_version.major == 1)
298 for(i = 0; i < max_constants; i++) {
299 if(!dirty_consts[i]) continue;
303 if (constants[j + 0] > 1.0f) lcl_const[0] = 1.0f;
304 else if (constants[j + 0] < -1.0f) lcl_const[0] = -1.0f;
305 else lcl_const[0] = constants[j + 0];
307 if (constants[j + 1] > 1.0f) lcl_const[1] = 1.0f;
308 else if (constants[j + 1] < -1.0f) lcl_const[1] = -1.0f;
309 else lcl_const[1] = constants[j + 1];
311 if (constants[j + 2] > 1.0f) lcl_const[2] = 1.0f;
312 else if (constants[j + 2] < -1.0f) lcl_const[2] = -1.0f;
313 else lcl_const[2] = constants[j + 2];
315 if (constants[j + 3] > 1.0f) lcl_const[3] = 1.0f;
316 else if (constants[j + 3] < -1.0f) lcl_const[3] = -1.0f;
317 else lcl_const[3] = constants[j + 3];
319 GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, i, lcl_const));
322 if(GL_SUPPORT(EXT_GPU_PROGRAM_PARAMETERS)) {
323 /* TODO: Benchmark if we're better of with finding the dirty constants ourselves,
324 * or just reloading *all* constants at once
326 GL_EXTCALL(glProgramEnvParameters4fvEXT(target_type, 0, max_constants, constants));
328 for(i = 0; i < max_constants; i++) {
329 if(!dirty_consts[i]) continue;
331 /* Find the next block of dirty constants */
334 for(i++; (i < max_constants) && dirty_consts[i]; i++) {
338 GL_EXTCALL(glProgramEnvParameters4fvEXT(target_type, j, i - j, constants + (j * 4)));
341 for(i = 0; i < max_constants; i++) {
342 if(dirty_consts[i]) {
344 GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, i, constants + (i * 4)));
349 checkGLcall("glProgramEnvParameter4fvARB()");
351 /* Load immediate constants */
352 if(This->baseShader.load_local_constsF) {
353 if (TRACE_ON(d3d_shader)) {
354 LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
355 GLfloat* values = (GLfloat*)lconst->value;
356 TRACE_(d3d_constants)("Loading local constants %i: %f, %f, %f, %f\n", lconst->idx,
357 values[0], values[1], values[2], values[3]);
360 /* Immediate constants are clamped for 1.X shaders at loading times */
362 LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
363 dirty_consts[lconst->idx] = 1; /* Dirtify so the non-immediate constant overwrites it next time */
364 ret = max(ret, lconst->idx + 1);
365 GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, lconst->idx, (GLfloat*)lconst->value));
367 checkGLcall("glProgramEnvParameter4fvARB()");
368 return ret; /* The loaded immediate constants need reloading for the next shader */
370 return 0; /* No constants are dirty now */
375 * Loads the texture dimensions for NP2 fixup into the currently set ARB_[vertex/fragment]_programs.
377 static void shader_arb_load_np2fixup_constants(
378 IWineD3DDevice* device,
380 char useVertexShader) {
382 IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl *) device;
383 const struct shader_arb_priv* const priv = (const struct shader_arb_priv *) deviceImpl->shader_priv;
384 IWineD3DStateBlockImpl* stateBlock = deviceImpl->stateBlock;
385 const WineD3D_GL_Info *gl_info = &deviceImpl->adapter->gl_info;
387 if (!usePixelShader) {
388 /* NP2 texcoord fixup is (currently) only done for pixelshaders. */
392 if (priv->compiled_fprog && priv->compiled_fprog->np2fixup_info.super.active) {
393 const struct arb_ps_np2fixup_info* const fixup = &priv->compiled_fprog->np2fixup_info;
395 WORD active = fixup->super.active;
396 GLfloat np2fixup_constants[4 * MAX_FRAGMENT_SAMPLERS];
398 for (i = 0; active; active >>= 1, ++i) {
399 const unsigned char idx = fixup->super.idx[i];
400 const IWineD3DTextureImpl* const tex = (const IWineD3DTextureImpl*) stateBlock->textures[i];
401 GLfloat* tex_dim = &np2fixup_constants[(idx >> 1) * 4];
403 if (!(active & 1)) continue;
406 FIXME("Nonexistent texture is flagged for NP2 texcoord fixup\n");
411 tex_dim[2] = tex->baseTexture.pow2Matrix[0]; tex_dim[3] = tex->baseTexture.pow2Matrix[5];
413 tex_dim[0] = tex->baseTexture.pow2Matrix[0]; tex_dim[1] = tex->baseTexture.pow2Matrix[5];
417 for (i = 0; i < fixup->super.num_consts; ++i) {
418 GL_EXTCALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB,
419 fixup->offset + i, &np2fixup_constants[i * 4]));
424 /* GL locking is done by the caller. */
425 static inline void shader_arb_ps_local_constants(IWineD3DDeviceImpl* deviceImpl)
427 IWineD3DStateBlockImpl* stateBlock = deviceImpl->stateBlock;
428 const WineD3D_GL_Info *gl_info = &deviceImpl->adapter->gl_info;
430 struct shader_arb_priv *priv = deviceImpl->shader_priv;
431 const struct arb_ps_compiled_shader *gl_shader = priv->compiled_fprog;
433 for(i = 0; i < gl_shader->numbumpenvmatconsts; i++)
435 int texunit = gl_shader->bumpenvmatconst[i].texunit;
437 /* The state manager takes care that this function is always called if the bump env matrix changes */
438 const float *data = (const float *)&stateBlock->textureState[texunit][WINED3DTSS_BUMPENVMAT00];
439 GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, gl_shader->bumpenvmatconst[i].const_num, data));
441 if (gl_shader->luminanceconst[i].const_num != WINED3D_CONST_NUM_UNUSED)
443 /* WINED3DTSS_BUMPENVLSCALE and WINED3DTSS_BUMPENVLOFFSET are next to each other.
444 * point gl to the scale, and load 4 floats. x = scale, y = offset, z and w are junk, we
445 * don't care about them. The pointers are valid for sure because the stateblock is bigger.
446 * (they're WINED3DTSS_TEXTURETRANSFORMFLAGS and WINED3DTSS_ADDRESSW, so most likely 0 or NaN
448 const float *scale = (const float *)&stateBlock->textureState[texunit][WINED3DTSS_BUMPENVLSCALE];
449 GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, gl_shader->luminanceconst[i].const_num, scale));
452 checkGLcall("Load bumpmap consts");
454 if(gl_shader->ycorrection != WINED3D_CONST_NUM_UNUSED)
456 /* ycorrection.x: Backbuffer height(onscreen) or 0(offscreen).
457 * ycorrection.y: -1.0(onscreen), 1.0(offscreen)
462 val[0] = deviceImpl->render_offscreen ? 0.0f : ((IWineD3DSurfaceImpl *) deviceImpl->render_targets[0])->currentDesc.Height;
463 val[1] = deviceImpl->render_offscreen ? 1.0f : -1.0f;
466 GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, gl_shader->ycorrection, val));
467 checkGLcall("y correction loading");
470 if(gl_shader->num_int_consts == 0) return;
472 for(i = 0; i < MAX_CONST_I; i++)
474 if(gl_shader->int_consts[i] != WINED3D_CONST_NUM_UNUSED)
477 val[0] = stateBlock->pixelShaderConstantI[4 * i];
478 val[1] = stateBlock->pixelShaderConstantI[4 * i + 1];
479 val[2] = stateBlock->pixelShaderConstantI[4 * i + 2];
482 GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, gl_shader->int_consts[i], val));
485 checkGLcall("Load ps int consts");
488 /* GL locking is done by the caller. */
489 static inline void shader_arb_vs_local_constants(IWineD3DDeviceImpl* deviceImpl)
491 IWineD3DStateBlockImpl* stateBlock;
492 const WineD3D_GL_Info *gl_info = &deviceImpl->adapter->gl_info;
494 struct shader_arb_priv *priv = deviceImpl->shader_priv;
495 const struct arb_vs_compiled_shader *gl_shader = priv->compiled_vprog;
497 /* Upload the position fixup */
498 GL_EXTCALL(glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, gl_shader->pos_fixup, deviceImpl->posFixup));
500 if(gl_shader->num_int_consts == 0) return;
502 stateBlock = deviceImpl->stateBlock;
504 for(i = 0; i < MAX_CONST_I; i++)
506 if(gl_shader->int_consts[i] != WINED3D_CONST_NUM_UNUSED)
509 val[0] = stateBlock->vertexShaderConstantI[4 * i];
510 val[1] = stateBlock->vertexShaderConstantI[4 * i + 1];
511 val[2] = stateBlock->vertexShaderConstantI[4 * i + 2];
514 GL_EXTCALL(glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, gl_shader->int_consts[i], val));
517 checkGLcall("Load vs int consts");
521 * Loads the app-supplied constants into the currently set ARB_[vertex/fragment]_programs.
523 * We only support float constants in ARB at the moment, so don't
524 * worry about the Integers or Booleans
526 /* GL locking is done by the caller (state handler) */
527 static void shader_arb_load_constants(
528 IWineD3DDevice* device,
530 char useVertexShader) {
532 IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) device;
533 IWineD3DStateBlockImpl* stateBlock = deviceImpl->stateBlock;
534 const WineD3D_GL_Info *gl_info = &deviceImpl->adapter->gl_info;
536 if (useVertexShader) {
537 IWineD3DBaseShaderImpl* vshader = (IWineD3DBaseShaderImpl*) stateBlock->vertexShader;
539 /* Load DirectX 9 float constants for vertex shader */
540 deviceImpl->highest_dirty_vs_const = shader_arb_load_constantsF(
541 vshader, gl_info, GL_VERTEX_PROGRAM_ARB,
542 deviceImpl->highest_dirty_vs_const,
543 stateBlock->vertexShaderConstantF,
544 deviceImpl->activeContext->vshader_const_dirty);
546 shader_arb_vs_local_constants(deviceImpl);
549 if (usePixelShader) {
550 IWineD3DBaseShaderImpl* pshader = (IWineD3DBaseShaderImpl*) stateBlock->pixelShader;
552 /* Load DirectX 9 float constants for pixel shader */
553 deviceImpl->highest_dirty_ps_const = shader_arb_load_constantsF(
554 pshader, gl_info, GL_FRAGMENT_PROGRAM_ARB,
555 deviceImpl->highest_dirty_ps_const,
556 stateBlock->pixelShaderConstantF,
557 deviceImpl->activeContext->pshader_const_dirty);
558 shader_arb_ps_local_constants(deviceImpl);
562 static void shader_arb_update_float_vertex_constants(IWineD3DDevice *iface, UINT start, UINT count)
564 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
566 /* We don't want shader constant dirtification to be an O(contexts), so just dirtify the active
567 * context. On a context switch the old context will be fully dirtified */
568 memset(This->activeContext->vshader_const_dirty + start, 1,
569 sizeof(*This->activeContext->vshader_const_dirty) * count);
570 This->highest_dirty_vs_const = max(This->highest_dirty_vs_const, start + count);
573 static void shader_arb_update_float_pixel_constants(IWineD3DDevice *iface, UINT start, UINT count)
575 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
577 /* We don't want shader constant dirtification to be an O(contexts), so just dirtify the active
578 * context. On a context switch the old context will be fully dirtified */
579 memset(This->activeContext->pshader_const_dirty + start, 1,
580 sizeof(*This->activeContext->pshader_const_dirty) * count);
581 This->highest_dirty_ps_const = max(This->highest_dirty_ps_const, start + count);
584 static DWORD *local_const_mapping(IWineD3DBaseShaderImpl *This)
588 const local_constant *lconst;
590 if(This->baseShader.load_local_constsF || list_empty(&This->baseShader.constantsF)) return NULL;
592 ret = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD) * This->baseShader.limits.constant_float);
594 ERR("Out of memory\n");
598 LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
599 ret[lconst->idx] = idx++;
604 /* Generate the variable & register declarations for the ARB_vertex_program output target */
605 static DWORD shader_generate_arb_declarations(IWineD3DBaseShader *iface, const shader_reg_maps *reg_maps,
606 struct wined3d_shader_buffer *buffer, const WineD3D_GL_Info *gl_info, DWORD *lconst_map,
607 DWORD *num_clipplanes, struct shader_arb_ctx_priv *ctx)
609 IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
610 DWORD i, next_local = 0;
611 char pshader = shader_is_pshader_version(reg_maps->shader_version.type);
612 unsigned max_constantsF;
613 const local_constant *lconst;
615 /* In pixel shaders, all private constants are program local, we don't need anything
616 * from program.env. Thus we can advertise the full set of constants in pixel shaders.
617 * If we need a private constant the GL implementation will squeeze it in somewhere
619 * With vertex shaders we need the posFixup and on some GL implementations 4 helper
620 * immediate values. The posFixup is loaded using program.env for now, so always
621 * subtract one from the number of constants. If the shader uses indirect addressing,
622 * account for the helper const too because we have to declare all availabke d3d constants
623 * and don't know which are actually used.
626 max_constantsF = GL_LIMITS(pshader_constantsF);
628 if(This->baseShader.reg_maps.usesrelconstF) {
629 DWORD highest_constf = 0, clip_limit;
630 max_constantsF = GL_LIMITS(vshader_constantsF) - reserved_vs_const(iface, gl_info);
631 max_constantsF -= count_bits(This->baseShader.reg_maps.integer_constants);
633 for(i = 0; i < This->baseShader.limits.constant_float; i++)
636 DWORD shift = i & 0x1f;
637 if(reg_maps->constf[idx] & (1 << shift)) highest_constf = i;
640 clip_limit = GL_LIMITS(clipplanes);
641 if(ctx->target_version == ARB) clip_limit = min(clip_limit, 4);
642 *num_clipplanes = min(clip_limit, max_constantsF - highest_constf - 1);
643 max_constantsF -= *num_clipplanes;
644 if(*num_clipplanes < clip_limit)
646 WARN("Only %u clipplanes out of %u enabled\n", *num_clipplanes, GL_LIMITS(clipplanes));
651 if(ctx->target_version >= NV2) *num_clipplanes = GL_LIMITS(clipplanes);
652 else *num_clipplanes = min(GL_LIMITS(clipplanes), 4);
653 max_constantsF = GL_LIMITS(vshader_constantsF);
657 for(i = 0; i < This->baseShader.limits.temporary; i++) {
658 if (reg_maps->temporary[i])
659 shader_addline(buffer, "TEMP R%u;\n", i);
662 for (i = 0; i < This->baseShader.limits.address; i++) {
663 if (reg_maps->address[i])
664 shader_addline(buffer, "ADDRESS A%d;\n", i);
667 if(pshader && reg_maps->shader_version.major == 1 && reg_maps->shader_version.minor <= 3) {
668 for(i = 0; i < This->baseShader.limits.texcoord; i++) {
669 if (reg_maps->texcoord[i] && pshader)
670 shader_addline(buffer,"TEMP T%u;\n", i);
674 /* Load local constants using the program-local space,
675 * this avoids reloading them each time the shader is used
678 LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
679 shader_addline(buffer, "PARAM C%u = program.local[%u];\n", lconst->idx,
680 lconst_map[lconst->idx]);
681 next_local = max(next_local, lconst_map[lconst->idx] + 1);
685 /* we use the array-based constants array if the local constants are marked for loading,
686 * because then we use indirect addressing, or when the local constant list is empty,
687 * because then we don't know if we're using indirect addressing or not. If we're hardcoding
688 * local constants do not declare the loaded constants as an array because ARB compilers usually
689 * do not optimize unused constants away
691 if(This->baseShader.reg_maps.usesrelconstF) {
692 /* Need to PARAM the environment parameters (constants) so we can use relative addressing */
693 shader_addline(buffer, "PARAM C[%d] = { program.env[0..%d] };\n",
694 max_constantsF, max_constantsF - 1);
696 for(i = 0; i < max_constantsF; i++) {
699 mask = 1 << (i & 0x1f);
700 if(!shader_constant_is_local(This, i) && (This->baseShader.reg_maps.constf[idx] & mask)) {
701 shader_addline(buffer, "PARAM C%d = program.env[%d];\n",i, i);
709 static const char * const shift_tab[] = {
710 "dummy", /* 0 (none) */
711 "coefmul.x", /* 1 (x2) */
712 "coefmul.y", /* 2 (x4) */
713 "coefmul.z", /* 3 (x8) */
714 "coefmul.w", /* 4 (x16) */
715 "dummy", /* 5 (x32) */
716 "dummy", /* 6 (x64) */
717 "dummy", /* 7 (x128) */
718 "dummy", /* 8 (d256) */
719 "dummy", /* 9 (d128) */
720 "dummy", /* 10 (d64) */
721 "dummy", /* 11 (d32) */
722 "coefdiv.w", /* 12 (d16) */
723 "coefdiv.z", /* 13 (d8) */
724 "coefdiv.y", /* 14 (d4) */
725 "coefdiv.x" /* 15 (d2) */
728 static void shader_arb_get_write_mask(const struct wined3d_shader_instruction *ins,
729 const struct wined3d_shader_dst_param *dst, char *write_mask)
731 char *ptr = write_mask;
733 if (dst->write_mask != WINED3DSP_WRITEMASK_ALL)
736 if (dst->write_mask & WINED3DSP_WRITEMASK_0) *ptr++ = 'x';
737 if (dst->write_mask & WINED3DSP_WRITEMASK_1) *ptr++ = 'y';
738 if (dst->write_mask & WINED3DSP_WRITEMASK_2) *ptr++ = 'z';
739 if (dst->write_mask & WINED3DSP_WRITEMASK_3) *ptr++ = 'w';
745 static void shader_arb_get_swizzle(const struct wined3d_shader_src_param *param, BOOL fixup, char *swizzle_str)
747 /* For registers of type WINED3DDECLTYPE_D3DCOLOR, data is stored as "bgra",
748 * but addressed as "rgba". To fix this we need to swap the register's x
749 * and z components. */
750 const char *swizzle_chars = fixup ? "zyxw" : "xyzw";
751 char *ptr = swizzle_str;
753 /* swizzle bits fields: wwzzyyxx */
754 DWORD swizzle = param->swizzle;
755 DWORD swizzle_x = swizzle & 0x03;
756 DWORD swizzle_y = (swizzle >> 2) & 0x03;
757 DWORD swizzle_z = (swizzle >> 4) & 0x03;
758 DWORD swizzle_w = (swizzle >> 6) & 0x03;
760 /* If the swizzle is the default swizzle (ie, "xyzw"), we don't need to
761 * generate a swizzle string. Unless we need to our own swizzling. */
762 if (swizzle != WINED3DSP_NOSWIZZLE || fixup)
765 if (swizzle_x == swizzle_y && swizzle_x == swizzle_z && swizzle_x == swizzle_w) {
766 *ptr++ = swizzle_chars[swizzle_x];
768 *ptr++ = swizzle_chars[swizzle_x];
769 *ptr++ = swizzle_chars[swizzle_y];
770 *ptr++ = swizzle_chars[swizzle_z];
771 *ptr++ = swizzle_chars[swizzle_w];
778 static void shader_arb_request_a0(const struct wined3d_shader_instruction *ins, const char *src)
780 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
781 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
783 if(strcmp(priv->addr_reg, src) == 0) return;
785 strcpy(priv->addr_reg, src);
786 shader_addline(buffer, "ARL A0.x, %s;\n", src);
789 static void shader_arb_get_src_param(const struct wined3d_shader_instruction *ins,
790 const struct wined3d_shader_src_param *src, unsigned int tmpreg, char *outregstr);
792 static void shader_arb_get_register_name(const struct wined3d_shader_instruction *ins,
793 const struct wined3d_shader_register *reg, char *register_name, BOOL *is_color)
795 /* oPos, oFog and oPts in D3D */
796 static const char * const rastout_reg_names[] = {"TMP_OUT", "result.fogcoord", "result.pointsize"};
797 IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
798 BOOL pshader = shader_is_pshader_version(This->baseShader.reg_maps.shader_version.type);
799 struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
805 case WINED3DSPR_TEMP:
806 sprintf(register_name, "R%u", reg->idx);
809 case WINED3DSPR_INPUT:
812 if(This->baseShader.reg_maps.shader_version.major < 3)
814 if (reg->idx == 0) strcpy(register_name, "fragment.color.primary");
815 else strcpy(register_name, "fragment.color.secondary");
822 shader_arb_get_src_param(ins, reg->rel_addr, 0, rel_reg);
824 if(strcmp(rel_reg, "**aL_emul**") == 0)
826 DWORD idx = ctx->aL + reg->idx;
827 if(idx < MAX_REG_INPUT)
829 strcpy(register_name, ctx->ps_input[idx]);
833 ERR("Pixel shader input register out of bounds: %u\n", idx);
834 sprintf(register_name, "out_of_bounds_%u", idx);
837 else if(This->baseShader.reg_maps.input_registers & 0x0300)
839 /* There are two ways basically:
841 * 1) Use the unrolling code that is used for loop emulation and unroll the loop.
842 * That means trouble if the loop also contains a breakc or if the control values
843 * aren't local constants.
844 * 2) Generate an if block that checks if aL.y < 8, == 8 or == 9 and selects the
845 * source dynamically. The trouble is that we cannot simply read aL.y because it
846 * is an ADDRESS register. We could however push it, load .zw with a value and use
847 * ADAC to load the condition code register and pop it again afterwards
849 FIXME("Relative input register addressing with more than 8 registers\n");
851 /* This is better than nothing for now */
852 sprintf(register_name, "fragment.texcoord[%s + %u]", rel_reg, reg->idx);
854 else if(ctx->cur_ps_args->super.vp_mode != vertexshader)
856 /* This is problematic because we'd have to consult the ctx->ps_input strings
857 * for where to find the varying. Some may be "0.0", others can be texcoords or
858 * colors. This needs either a pipeline replacement to make the vertex shader feed
859 * proper varyings, or loop unrolling
861 * For now use the texcoords and hope for the best
863 FIXME("Non-vertex shader varying input with indirect addressing\n");
864 sprintf(register_name, "fragment.texcoord[%s + %u]", rel_reg, reg->idx);
868 /* D3D supports indirect addressing only with aL in loop registers. The loop instruction
869 * pulls GL_NV_fragment_program2 in
871 sprintf(register_name, "fragment.texcoord[%s + %u]", rel_reg, reg->idx);
876 if(reg->idx < MAX_REG_INPUT)
878 strcpy(register_name, ctx->ps_input[reg->idx]);
882 ERR("Pixel shader input register out of bounds: %u\n", reg->idx);
883 sprintf(register_name, "out_of_bounds_%u", reg->idx);
890 if (ctx->cur_vs_args->super.swizzle_map & (1 << reg->idx)) *is_color = TRUE;
891 sprintf(register_name, "vertex.attrib[%u]", reg->idx);
895 case WINED3DSPR_CONST:
896 if (!pshader && reg->rel_addr)
900 UINT rel_offset = ((IWineD3DVertexShaderImpl *)This)->rel_offset;
901 if(This->baseShader.reg_maps.shader_version.major < 2) {
902 sprintf(rel_reg, "A0.x");
904 shader_arb_get_src_param(ins, reg->rel_addr, 0, rel_reg);
905 if(ctx->target_version == ARB) {
906 if(strcmp(rel_reg, "**aL_emul**") == 0) {
909 shader_arb_request_a0(ins, rel_reg);
910 sprintf(rel_reg, "A0.x");
915 sprintf(register_name, "C[%u]", ctx->aL + reg->idx);
916 else if (reg->idx >= rel_offset)
917 sprintf(register_name, "C[%s + %u]", rel_reg, reg->idx - rel_offset);
919 sprintf(register_name, "C[%s - %u]", rel_reg, -reg->idx + rel_offset);
923 if (This->baseShader.reg_maps.usesrelconstF)
924 sprintf(register_name, "C[%u]", reg->idx);
926 sprintf(register_name, "C%u", reg->idx);
930 case WINED3DSPR_TEXTURE: /* case WINED3DSPR_ADDR: */
932 if(This->baseShader.reg_maps.shader_version.major == 1 &&
933 This->baseShader.reg_maps.shader_version.minor <= 3) {
934 /* In ps <= 1.3, Tx is a temporary register as destination to all instructions,
935 * and as source to most instructions. For some instructions it is the texcoord
936 * input. Those instructions know about the special use
938 sprintf(register_name, "T%u", reg->idx);
940 /* in ps 1.4 and 2.x Tx is always a (read-only) varying */
941 sprintf(register_name, "fragment.texcoord[%u]", reg->idx);
946 if(This->baseShader.reg_maps.shader_version.major == 1 || ctx->target_version >= NV2)
948 sprintf(register_name, "A%u", reg->idx);
952 sprintf(register_name, "A%u_SHADOW", reg->idx);
957 case WINED3DSPR_COLOROUT:
958 if(ctx->cur_ps_args->super.srgb_correction && reg->idx == 0)
960 strcpy(register_name, "TMP_COLOR");
964 if(ctx->cur_ps_args->super.srgb_correction) FIXME("sRGB correction on higher render targets\n");
965 if(This->baseShader.reg_maps.highest_render_target > 0)
967 sprintf(register_name, "result.color[%u]", reg->idx);
971 strcpy(register_name, "result.color");
976 case WINED3DSPR_RASTOUT:
977 if(reg->idx == 1) sprintf(register_name, "%s", ctx->fog_output);
978 else sprintf(register_name, "%s", rastout_reg_names[reg->idx]);
981 case WINED3DSPR_DEPTHOUT:
982 strcpy(register_name, "result.depth");
985 case WINED3DSPR_ATTROUT:
986 /* case WINED3DSPR_OUTPUT: */
987 if (pshader) sprintf(register_name, "oD[%u]", reg->idx);
988 else strcpy(register_name, ctx->color_output[reg->idx]);
991 case WINED3DSPR_TEXCRDOUT:
994 sprintf(register_name, "oT[%u]", reg->idx);
998 if(This->baseShader.reg_maps.shader_version.major < 3)
1000 strcpy(register_name, ctx->texcrd_output[reg->idx]);
1004 strcpy(register_name, ctx->vs_output[reg->idx]);
1009 case WINED3DSPR_LOOP:
1010 if(ctx->target_version >= NV2)
1012 /* Pshader has an implicitly declared loop index counter A0.x that cannot be renamed */
1013 if(pshader) sprintf(register_name, "A0.x");
1014 else sprintf(register_name, "aL.y");
1018 /* Unfortunately this code cannot return the value of ctx->aL here. An immediate value
1019 * would be valid, but if aL is used for indexing(its only use), there's likely an offset,
1020 * thus the result would be something like C[15 + 30], which is not valid in the ARB program
1021 * grammar. So return a marker for the emulated aL and intercept it in constant and varying
1024 sprintf(register_name, "**aL_emul**");
1029 case WINED3DSPR_CONSTINT:
1030 sprintf(register_name, "I%u", reg->idx);
1033 case WINED3DSPR_MISCTYPE:
1036 sprintf(register_name, "vpos");
1038 else if(reg->idx == 1)
1040 sprintf(register_name, "fragment.facing.x");
1044 FIXME("Unknown MISCTYPE register index %u\n", reg->idx);
1049 FIXME("Unhandled register type %#x[%u]\n", reg->type, reg->idx);
1050 sprintf(register_name, "unrecognized_register[%u]", reg->idx);
1055 static void shader_arb_get_dst_param(const struct wined3d_shader_instruction *ins,
1056 const struct wined3d_shader_dst_param *wined3d_dst, char *str)
1058 char register_name[255];
1062 shader_arb_get_register_name(ins, &wined3d_dst->reg, register_name, &is_color);
1063 strcpy(str, register_name);
1065 shader_arb_get_write_mask(ins, wined3d_dst, write_mask);
1066 strcat(str, write_mask);
1069 static const char *shader_arb_get_fixup_swizzle(enum fixup_channel_source channel_source)
1071 switch(channel_source)
1073 case CHANNEL_SOURCE_ZERO: return "0";
1074 case CHANNEL_SOURCE_ONE: return "1";
1075 case CHANNEL_SOURCE_X: return "x";
1076 case CHANNEL_SOURCE_Y: return "y";
1077 case CHANNEL_SOURCE_Z: return "z";
1078 case CHANNEL_SOURCE_W: return "w";
1080 FIXME("Unhandled channel source %#x\n", channel_source);
1085 static void gen_color_correction(struct wined3d_shader_buffer *buffer, const char *reg,
1086 DWORD dst_mask, const char *one, const char *two, struct color_fixup_desc fixup)
1090 if (is_yuv_fixup(fixup))
1092 enum yuv_fixup yuv_fixup = get_yuv_fixup(fixup);
1093 FIXME("YUV fixup (%#x) not supported\n", yuv_fixup);
1098 if (fixup.x_source != CHANNEL_SOURCE_X) mask |= WINED3DSP_WRITEMASK_0;
1099 if (fixup.y_source != CHANNEL_SOURCE_Y) mask |= WINED3DSP_WRITEMASK_1;
1100 if (fixup.z_source != CHANNEL_SOURCE_Z) mask |= WINED3DSP_WRITEMASK_2;
1101 if (fixup.w_source != CHANNEL_SOURCE_W) mask |= WINED3DSP_WRITEMASK_3;
1106 shader_addline(buffer, "SWZ %s, %s, %s, %s, %s, %s;\n", reg, reg,
1107 shader_arb_get_fixup_swizzle(fixup.x_source), shader_arb_get_fixup_swizzle(fixup.y_source),
1108 shader_arb_get_fixup_swizzle(fixup.z_source), shader_arb_get_fixup_swizzle(fixup.w_source));
1112 if (fixup.x_sign_fixup) mask |= WINED3DSP_WRITEMASK_0;
1113 if (fixup.y_sign_fixup) mask |= WINED3DSP_WRITEMASK_1;
1114 if (fixup.z_sign_fixup) mask |= WINED3DSP_WRITEMASK_2;
1115 if (fixup.w_sign_fixup) mask |= WINED3DSP_WRITEMASK_3;
1121 char *ptr = reg_mask;
1123 if (mask != WINED3DSP_WRITEMASK_ALL)
1126 if (mask & WINED3DSP_WRITEMASK_0) *ptr++ = 'x';
1127 if (mask & WINED3DSP_WRITEMASK_1) *ptr++ = 'y';
1128 if (mask & WINED3DSP_WRITEMASK_2) *ptr++ = 'z';
1129 if (mask & WINED3DSP_WRITEMASK_3) *ptr++ = 'w';
1133 shader_addline(buffer, "MAD %s%s, %s, %s, -%s;\n", reg, reg_mask, reg, two, one);
1137 static const char *shader_arb_get_modifier(const struct wined3d_shader_instruction *ins)
1140 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
1141 if (!ins->dst_count) return "";
1143 mod = ins->dst[0].modifiers;
1145 /* Silently ignore PARTIALPRECISION if its not supported */
1146 if(priv->target_version == ARB) mod &= ~WINED3DSPDM_PARTIALPRECISION;
1148 if(mod & WINED3DSPDM_MSAMPCENTROID)
1150 FIXME("Unhandled modifier WINED3DSPDM_MSAMPCENTROID\n");
1151 mod &= ~WINED3DSPDM_MSAMPCENTROID;
1156 case WINED3DSPDM_SATURATE | WINED3DSPDM_PARTIALPRECISION:
1159 case WINED3DSPDM_SATURATE:
1162 case WINED3DSPDM_PARTIALPRECISION:
1169 FIXME("Unknown modifiers 0x%08x\n", mod);
1174 #define TEX_PROJ 0x1
1175 #define TEX_BIAS 0x2
1177 #define TEX_DERIV 0x10
1179 static void shader_hw_sample(const struct wined3d_shader_instruction *ins, DWORD sampler_idx,
1180 const char *dst_str, const char *coord_reg, WORD flags, const char *dsx, const char *dsy)
1182 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1183 DWORD sampler_type = ins->ctx->reg_maps->sampler_type[sampler_idx];
1184 const char *tex_type;
1185 BOOL np2_fixup = FALSE;
1186 IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
1187 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device;
1188 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
1190 BOOL pshader = shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type);
1192 /* D3D vertex shader sampler IDs are vertex samplers(0-3), not global d3d samplers */
1193 if(!pshader) sampler_idx += MAX_FRAGMENT_SAMPLERS;
1195 switch(sampler_type) {
1201 if(device->stateBlock->textures[sampler_idx] &&
1202 IWineD3DBaseTexture_GetTextureDimensions(device->stateBlock->textures[sampler_idx]) == GL_TEXTURE_RECTANGLE_ARB) {
1207 if (shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type))
1209 if (priv->cur_np2fixup_info->super.active & (1 << sampler_idx))
1211 if (flags) FIXME("Only ordinary sampling from NP2 textures is supported.\n");
1212 else np2_fixup = TRUE;
1217 case WINED3DSTT_VOLUME:
1221 case WINED3DSTT_CUBE:
1226 ERR("Unexpected texture type %d\n", sampler_type);
1230 /* TEX, TXL, TXD and TXP do not support the "H" modifier,
1231 * so don't use shader_arb_get_modifier
1233 if(ins->dst[0].modifiers & WINED3DSPDM_SATURATE) mod = "_SAT";
1236 /* Fragment samplers always have indentity mapping */
1237 if(sampler_idx >= MAX_FRAGMENT_SAMPLERS)
1239 sampler_idx = priv->cur_vs_args->vertex_samplers[sampler_idx - MAX_FRAGMENT_SAMPLERS];
1242 if (flags & TEX_DERIV)
1244 if(flags & TEX_PROJ) FIXME("Projected texture sampling with custom derivates\n");
1245 if(flags & TEX_BIAS) FIXME("Biased texture sampling with custom derivates\n");
1246 shader_addline(buffer, "TXD%s %s, %s, %s, %s, texture[%u], %s;\n", mod, dst_str, coord_reg,
1247 dsx, dsy,sampler_idx, tex_type);
1249 else if(flags & TEX_LOD)
1251 if(flags & TEX_PROJ) FIXME("Projected texture sampling with explicit lod\n");
1252 if(flags & TEX_BIAS) FIXME("Biased texture sampling with explicit lod\n");
1253 shader_addline(buffer, "TXL%s %s, %s, texture[%u], %s;\n", mod, dst_str, coord_reg,
1254 sampler_idx, tex_type);
1256 else if (flags & TEX_BIAS)
1258 /* Shouldn't be possible, but let's check for it */
1259 if(flags & TEX_PROJ) FIXME("Biased and Projected texture sampling\n");
1260 /* TXB takes the 4th component of the source vector automatically, as d3d. Nothing more to do */
1261 shader_addline(buffer, "TXB%s %s, %s, texture[%u], %s;\n", mod, dst_str, coord_reg, sampler_idx, tex_type);
1263 else if (flags & TEX_PROJ)
1265 shader_addline(buffer, "TXP%s %s, %s, texture[%u], %s;\n", mod, dst_str, coord_reg, sampler_idx, tex_type);
1271 const unsigned char idx = priv->cur_np2fixup_info->super.idx[sampler_idx];
1272 shader_addline(buffer, "MUL TA, np2fixup[%u].%s, %s;\n", idx >> 1,
1273 (idx % 2) ? "zwxy" : "xyzw", coord_reg);
1275 shader_addline(buffer, "TEX%s %s, TA, texture[%u], %s;\n", mod, dst_str, sampler_idx, tex_type);
1278 shader_addline(buffer, "TEX%s %s, %s, texture[%u], %s;\n", mod, dst_str, coord_reg, sampler_idx, tex_type);
1283 gen_color_correction(buffer, dst_str, ins->dst[0].write_mask,
1284 "one", "coefmul.x", priv->cur_ps_args->super.color_fixup[sampler_idx]);
1288 static void shader_arb_get_src_param(const struct wined3d_shader_instruction *ins,
1289 const struct wined3d_shader_src_param *src, unsigned int tmpreg, char *outregstr)
1291 /* Generate a line that does the input modifier computation and return the input register to use */
1292 BOOL is_color = FALSE;
1296 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1297 struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
1299 /* Assume a new line will be added */
1302 /* Get register name */
1303 shader_arb_get_register_name(ins, &src->reg, regstr, &is_color);
1304 shader_arb_get_swizzle(src, is_color, swzstr);
1306 switch (src->modifiers)
1308 case WINED3DSPSM_NONE:
1309 sprintf(outregstr, "%s%s", regstr, swzstr);
1312 case WINED3DSPSM_NEG:
1313 sprintf(outregstr, "-%s%s", regstr, swzstr);
1316 case WINED3DSPSM_BIAS:
1317 shader_addline(buffer, "ADD T%c, %s, -coefdiv.x;\n", 'A' + tmpreg, regstr);
1319 case WINED3DSPSM_BIASNEG:
1320 shader_addline(buffer, "ADD T%c, -%s, coefdiv.x;\n", 'A' + tmpreg, regstr);
1322 case WINED3DSPSM_SIGN:
1323 shader_addline(buffer, "MAD T%c, %s, coefmul.x, -one.x;\n", 'A' + tmpreg, regstr);
1325 case WINED3DSPSM_SIGNNEG:
1326 shader_addline(buffer, "MAD T%c, %s, -coefmul.x, one.x;\n", 'A' + tmpreg, regstr);
1328 case WINED3DSPSM_COMP:
1329 shader_addline(buffer, "SUB T%c, one.x, %s;\n", 'A' + tmpreg, regstr);
1331 case WINED3DSPSM_X2:
1332 shader_addline(buffer, "ADD T%c, %s, %s;\n", 'A' + tmpreg, regstr, regstr);
1334 case WINED3DSPSM_X2NEG:
1335 shader_addline(buffer, "ADD T%c, -%s, -%s;\n", 'A' + tmpreg, regstr, regstr);
1337 case WINED3DSPSM_DZ:
1338 shader_addline(buffer, "RCP T%c, %s.z;\n", 'A' + tmpreg, regstr);
1339 shader_addline(buffer, "MUL T%c, %s, T%c;\n", 'A' + tmpreg, regstr, 'A' + tmpreg);
1341 case WINED3DSPSM_DW:
1342 shader_addline(buffer, "RCP T%c, %s.w;\n", 'A' + tmpreg, regstr);
1343 shader_addline(buffer, "MUL T%c, %s, T%c;\n", 'A' + tmpreg, regstr, 'A' + tmpreg);
1345 case WINED3DSPSM_ABS:
1346 if(ctx->target_version >= NV2) {
1347 sprintf(outregstr, "|%s%s|", regstr, swzstr);
1350 shader_addline(buffer, "ABS T%c, %s;\n", 'A' + tmpreg, regstr);
1353 case WINED3DSPSM_ABSNEG:
1354 if(ctx->target_version >= NV2) {
1355 sprintf(outregstr, "-|%s%s|", regstr, swzstr);
1357 shader_addline(buffer, "ABS T%c, %s;\n", 'A' + tmpreg, regstr);
1358 sprintf(outregstr, "-T%c%s", 'A' + tmpreg, swzstr);
1363 sprintf(outregstr, "%s%s", regstr, swzstr);
1367 /* Return modified or original register, with swizzle */
1369 sprintf(outregstr, "T%c%s", 'A' + tmpreg, swzstr);
1372 static void pshader_hw_bem(const struct wined3d_shader_instruction *ins)
1374 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1375 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1377 char src_name[2][50];
1378 DWORD sampler_code = dst->reg.idx;
1380 shader_arb_get_dst_param(ins, dst, dst_name);
1382 /* Sampling the perturbation map in Tsrc was done already, including the signedness correction if needed
1384 * Keep in mind that src_name[1] can be "TB" and src_name[0] can be "TA" because modifiers like _x2 are valid
1385 * with bem. So delay loading the first parameter until after the perturbation calculation which needs two
1388 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
1389 shader_addline(buffer, "SWZ TA, bumpenvmat%d, x, z, 0, 0;\n", sampler_code);
1390 shader_addline(buffer, "DP3 TC.r, TA, %s;\n", src_name[1]);
1391 shader_addline(buffer, "SWZ TA, bumpenvmat%d, y, w, 0, 0;\n", sampler_code);
1392 shader_addline(buffer, "DP3 TC.g, TA, %s;\n", src_name[1]);
1394 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name[0]);
1395 shader_addline(buffer, "ADD %s, %s, TC;\n", dst_name, src_name[0]);
1398 static DWORD negate_modifiers(DWORD mod, char *extra_char)
1403 case WINED3DSPSM_NONE: return WINED3DSPSM_NEG;
1404 case WINED3DSPSM_NEG: return WINED3DSPSM_NONE;
1405 case WINED3DSPSM_BIAS: return WINED3DSPSM_BIASNEG;
1406 case WINED3DSPSM_BIASNEG: return WINED3DSPSM_BIAS;
1407 case WINED3DSPSM_SIGN: return WINED3DSPSM_SIGNNEG;
1408 case WINED3DSPSM_SIGNNEG: return WINED3DSPSM_SIGN;
1409 case WINED3DSPSM_COMP: *extra_char = '-'; return WINED3DSPSM_COMP;
1410 case WINED3DSPSM_X2: return WINED3DSPSM_X2NEG;
1411 case WINED3DSPSM_X2NEG: return WINED3DSPSM_X2;
1412 case WINED3DSPSM_DZ: *extra_char = '-'; return WINED3DSPSM_DZ;
1413 case WINED3DSPSM_DW: *extra_char = '-'; return WINED3DSPSM_DW;
1414 case WINED3DSPSM_ABS: return WINED3DSPSM_ABSNEG;
1415 case WINED3DSPSM_ABSNEG: return WINED3DSPSM_ABS;
1417 FIXME("Unknown modifier %u\n", mod);
1421 static void pshader_hw_cnd(const struct wined3d_shader_instruction *ins)
1423 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1424 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1426 char src_name[3][50];
1427 DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
1428 ins->ctx->reg_maps->shader_version.minor);
1431 shader_arb_get_dst_param(ins, dst, dst_name);
1432 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
1434 /* The coissue flag changes the semantic of the cnd instruction in <= 1.3 shaders */
1435 if (shader_version <= WINED3D_SHADER_VERSION(1, 3) && ins->coissue)
1437 shader_addline(buffer, "MOV%s %s, %s;\n", shader_arb_get_modifier(ins), dst_name, src_name[1]);
1439 struct wined3d_shader_src_param src0_copy = ins->src[0];
1442 /* src0 may have a negate srcmod set, so we can't blindly add "-" to the name */
1443 src0_copy.modifiers = negate_modifiers(src0_copy.modifiers, &extra_neg);
1445 shader_arb_get_src_param(ins, &src0_copy, 0, src_name[0]);
1446 shader_arb_get_src_param(ins, &ins->src[2], 2, src_name[2]);
1447 shader_addline(buffer, "ADD TA, %c%s, coefdiv.x;\n", extra_neg, src_name[0]);
1448 /* No modifiers supported on CMP */
1449 shader_addline(buffer, "CMP %s, TA, %s, %s;\n", dst_name, src_name[1], src_name[2]);
1451 /* _SAT on CMP doesn't make much sense, but it is not a pure NOP */
1452 if(ins->dst[0].modifiers & WINED3DSPDM_SATURATE)
1454 shader_arb_get_register_name(ins, &dst->reg, src_name[0], &is_color);
1455 shader_addline(buffer, "MOV_SAT %s, %s;\n", dst_name, dst_name);
1460 static void pshader_hw_cmp(const struct wined3d_shader_instruction *ins)
1462 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1463 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1465 char src_name[3][50];
1468 shader_arb_get_dst_param(ins, dst, dst_name);
1470 /* Generate input register names (with modifiers) */
1471 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name[0]);
1472 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
1473 shader_arb_get_src_param(ins, &ins->src[2], 2, src_name[2]);
1475 /* No modifiers are supported on CMP */
1476 shader_addline(buffer, "CMP %s, %s, %s, %s;\n", dst_name,
1477 src_name[0], src_name[2], src_name[1]);
1479 if(ins->dst[0].modifiers & WINED3DSPDM_SATURATE)
1481 shader_arb_get_register_name(ins, &dst->reg, src_name[0], &is_color);
1482 shader_addline(buffer, "MOV_SAT %s, %s;\n", dst_name, src_name[0]);
1486 /** Process the WINED3DSIO_DP2ADD instruction in ARB.
1487 * dst = dot2(src0, src1) + src2 */
1488 static void pshader_hw_dp2add(const struct wined3d_shader_instruction *ins)
1490 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1491 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1493 char src_name[3][50];
1494 struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
1496 shader_arb_get_dst_param(ins, dst, dst_name);
1497 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name[0]);
1498 shader_arb_get_src_param(ins, &ins->src[2], 2, src_name[2]);
1500 if(ctx->target_version >= NV3)
1502 /* GL_NV_fragment_program2 has a 1:1 matching instruction */
1503 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
1504 shader_addline(buffer, "DP2A%s %s, %s, %s, %s;\n", shader_arb_get_modifier(ins),
1505 dst_name, src_name[0], src_name[1], src_name[2]);
1507 else if(ctx->target_version >= NV2)
1509 /* dst.x = src2.?, src0.x, src1.x + src0.y * src1.y
1510 * dst.y = src2.?, src0.x, src1.z + src0.y * src1.w
1511 * dst.z = src2.?, src0.x, src1.x + src0.y * src1.y
1512 * dst.z = src2.?, src0.x, src1.z + src0.y * src1.w
1514 * Make sure that src1.zw = src1.xy, then we get a classic dp2add
1516 * .xyxy and other swizzles that we could get with this are not valid in
1517 * plain ARBfp, but luckily the NV extension grammar lifts this limitation.
1519 struct wined3d_shader_src_param tmp_param = ins->src[1];
1520 DWORD swizzle = tmp_param.swizzle & 0xf; /* Selects .xy */
1521 tmp_param.swizzle = swizzle | (swizzle << 4); /* Creates .xyxy */
1523 shader_arb_get_src_param(ins, &tmp_param, 1, src_name[1]);
1525 shader_addline(buffer, "X2D%s %s, %s, %s, %s;\n", shader_arb_get_modifier(ins),
1526 dst_name, src_name[2], src_name[0], src_name[1]);
1530 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
1531 /* Emulate a DP2 with a DP3 and 0.0. Don't use the dest as temp register, it could be src[1] or src[2]
1532 * src_name[0] can be TA, but TA is a private temp for modifiers, so it is save to overwrite
1534 shader_addline(buffer, "MOV TA, %s;\n", src_name[0]);
1535 shader_addline(buffer, "MOV TA.z, 0.0;\n");
1536 shader_addline(buffer, "DP3 TA, TA, %s;\n", src_name[1]);
1537 shader_addline(buffer, "ADD%s %s, TA, %s;\n", shader_arb_get_modifier(ins), dst_name, src_name[2]);
1541 /* Map the opcode 1-to-1 to the GL code */
1542 static void shader_hw_map2gl(const struct wined3d_shader_instruction *ins)
1544 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1545 const char *instruction;
1546 char arguments[256], dst_str[50];
1548 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1550 switch (ins->handler_idx)
1552 case WINED3DSIH_ABS: instruction = "ABS"; break;
1553 case WINED3DSIH_ADD: instruction = "ADD"; break;
1554 case WINED3DSIH_CRS: instruction = "XPD"; break;
1555 case WINED3DSIH_DP3: instruction = "DP3"; break;
1556 case WINED3DSIH_DP4: instruction = "DP4"; break;
1557 case WINED3DSIH_DST: instruction = "DST"; break;
1558 case WINED3DSIH_EXP: instruction = "EX2"; break;
1559 case WINED3DSIH_EXPP: instruction = "EXP"; break;
1560 case WINED3DSIH_FRC: instruction = "FRC"; break;
1561 case WINED3DSIH_LIT: instruction = "LIT"; break;
1562 case WINED3DSIH_LRP: instruction = "LRP"; break;
1563 case WINED3DSIH_MAD: instruction = "MAD"; break;
1564 case WINED3DSIH_MAX: instruction = "MAX"; break;
1565 case WINED3DSIH_MIN: instruction = "MIN"; break;
1566 case WINED3DSIH_MOV: instruction = "MOV"; break;
1567 case WINED3DSIH_MUL: instruction = "MUL"; break;
1568 case WINED3DSIH_SGE: instruction = "SGE"; break;
1569 case WINED3DSIH_SLT: instruction = "SLT"; break;
1570 case WINED3DSIH_SUB: instruction = "SUB"; break;
1571 case WINED3DSIH_MOVA:instruction = "ARR"; break;
1572 case WINED3DSIH_SGN: instruction = "SSG"; break;
1573 case WINED3DSIH_DSX: instruction = "DDX"; break;
1574 default: instruction = "";
1575 FIXME("Unhandled opcode %#x\n", ins->handler_idx);
1579 /* Note that shader_arb_add_dst_param() adds spaces. */
1580 arguments[0] = '\0';
1581 shader_arb_get_dst_param(ins, dst, dst_str);
1582 for (i = 0; i < ins->src_count; ++i)
1585 strcat(arguments, ", ");
1586 shader_arb_get_src_param(ins, &ins->src[i], i, operand);
1587 strcat(arguments, operand);
1589 shader_addline(buffer, "%s%s %s%s;\n", instruction, shader_arb_get_modifier(ins), dst_str, arguments);
1592 static void shader_hw_nop(const struct wined3d_shader_instruction *ins)
1594 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1595 shader_addline(buffer, "NOP;\n");
1598 static void shader_hw_mov(const struct wined3d_shader_instruction *ins)
1600 IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
1601 BOOL pshader = shader_is_pshader_version(shader->baseShader.reg_maps.shader_version.type);
1602 struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
1604 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1605 char src0_param[256];
1607 if(ins->handler_idx == WINED3DSIH_MOVA) {
1608 struct wined3d_shader_src_param tmp_src = ins->src[0];
1611 if(ctx->target_version >= NV2) {
1612 shader_hw_map2gl(ins);
1615 tmp_src.swizzle = (tmp_src.swizzle & 0x3) * 0x55;
1616 shader_arb_get_src_param(ins, &tmp_src, 0, src0_param);
1617 shader_arb_get_write_mask(ins, &ins->dst[0], write_mask);
1619 /* This implements the mova formula used in GLSL. The first two instructions
1620 * prepare the sign() part. Note that it is fine to have my_sign(0.0) = 1.0
1624 * A0.x = arl(floor(abs(0.0) + 0.5) * 1.0) = floor(0.5) = 0.0 since arl does a floor
1626 * The ARL is performed when A0 is used - the requested component is read from A0_SHADOW into
1627 * A0.x. We can use the overwritten component of A0_shadow as temporary storage for the sign.
1629 shader_addline(buffer, "SGE A0_SHADOW%s, %s, mova_const.y;\n", write_mask, src0_param);
1630 shader_addline(buffer, "MAD A0_SHADOW%s, A0_SHADOW, mova_const.z, -mova_const.w;\n", write_mask);
1632 shader_addline(buffer, "ABS TA%s, %s;\n", write_mask, src0_param);
1633 shader_addline(buffer, "ADD TA%s, TA, mova_const.x;\n", write_mask);
1634 shader_addline(buffer, "FLR TA%s, TA;\n", write_mask);
1635 if (((IWineD3DVertexShaderImpl *)shader)->rel_offset)
1637 shader_addline(buffer, "ADD TA%s, TA, helper_const.z;\n", write_mask);
1639 shader_addline(buffer, "MUL A0_SHADOW%s, TA, A0_SHADOW;\n", write_mask);
1641 ((struct shader_arb_ctx_priv *)ins->ctx->backend_data)->addr_reg[0] = '\0';
1642 } else if (ins->ctx->reg_maps->shader_version.major == 1
1643 && !shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type)
1644 && ins->dst[0].reg.type == WINED3DSPR_ADDR)
1646 src0_param[0] = '\0';
1647 if (((IWineD3DVertexShaderImpl *)shader)->rel_offset)
1649 shader_arb_get_src_param(ins, &ins->src[0], 0, src0_param);
1650 shader_addline(buffer, "ADD TA.x, %s, helper_const.z;\n", src0_param);
1651 shader_addline(buffer, "ARL A0.x, TA.x;\n");
1655 /* Apple's ARB_vertex_program implementation does not accept an ARL source argument
1656 * with more than one component. Thus replicate the first source argument over all
1657 * 4 components. For example, .xyzw -> .x (or better: .xxxx), .zwxy -> .z, etc) */
1658 struct wined3d_shader_src_param tmp_src = ins->src[0];
1659 tmp_src.swizzle = (tmp_src.swizzle & 0x3) * 0x55;
1660 shader_arb_get_src_param(ins, &tmp_src, 0, src0_param);
1661 shader_addline(buffer, "ARL A0.x, %s;\n", src0_param);
1664 else if(ins->dst[0].reg.type == WINED3DSPR_COLOROUT && ins->dst[0].reg.idx == 0 && pshader)
1666 IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *) shader;
1667 if(ctx->cur_ps_args->super.srgb_correction && ps->color0_mov)
1669 shader_addline(buffer, "#mov handled in srgb write code\n");
1672 shader_hw_map2gl(ins);
1676 shader_hw_map2gl(ins);
1680 static void pshader_hw_texkill(const struct wined3d_shader_instruction *ins)
1682 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1683 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1686 /* No swizzles are allowed in d3d's texkill. PS 1.x ignores the 4th component as documented,
1687 * but >= 2.0 honors it(undocumented, but tested by the d3d9 testsuit)
1689 shader_arb_get_dst_param(ins, dst, reg_dest);
1691 if (ins->ctx->reg_maps->shader_version.major >= 2)
1693 const char *kilsrc = "TA";
1696 shader_arb_get_register_name(ins, &dst->reg, reg_dest, &is_color);
1697 if(dst->write_mask == WINED3DSP_WRITEMASK_ALL)
1703 /* Sigh. KIL doesn't support swizzles/writemasks. KIL passes a writemask, but ".xy" for example
1704 * is not valid as a swizzle in ARB (needs ".xyyy"). Use SWZ to load the register properly, and set
1705 * masked out components to 0(won't kill)
1707 char x = '0', y = '0', z = '0', w = '0';
1708 if(dst->write_mask & WINED3DSP_WRITEMASK_0) x = 'x';
1709 if(dst->write_mask & WINED3DSP_WRITEMASK_1) y = 'y';
1710 if(dst->write_mask & WINED3DSP_WRITEMASK_2) z = 'z';
1711 if(dst->write_mask & WINED3DSP_WRITEMASK_3) w = 'w';
1712 shader_addline(buffer, "SWZ TA, %s, %c, %c, %c, %c;\n", reg_dest, x, y, z, w);
1714 shader_addline(buffer, "KIL %s;\n", kilsrc);
1716 /* ARB fp doesn't like swizzles on the parameter of the KIL instruction. To mask the 4th component,
1717 * copy the register into our general purpose TMP variable, overwrite .w and pass TMP to KIL
1719 * ps_1_3 shaders use the texcoord incarnation of the Tx register. ps_1_4 shaders can use the same,
1720 * or pass in any temporary register(in shader phase 2)
1722 if(ins->ctx->reg_maps->shader_version.minor <= 3) {
1723 sprintf(reg_dest, "fragment.texcoord[%u]", dst->reg.idx);
1725 shader_arb_get_dst_param(ins, dst, reg_dest);
1727 shader_addline(buffer, "SWZ TA, %s, x, y, z, 1;\n", reg_dest);
1728 shader_addline(buffer, "KIL TA;\n");
1732 static void pshader_hw_tex(const struct wined3d_shader_instruction *ins)
1734 IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
1735 IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
1736 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1737 DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
1738 ins->ctx->reg_maps->shader_version.minor);
1739 struct wined3d_shader_src_param src;
1743 DWORD reg_sampler_code;
1746 /* All versions have a destination register */
1747 shader_arb_get_dst_param(ins, dst, reg_dest);
1749 /* 1.0-1.4: Use destination register number as texture code.
1750 2.0+: Use provided sampler number as texure code. */
1751 if (shader_version < WINED3D_SHADER_VERSION(2,0))
1752 reg_sampler_code = dst->reg.idx;
1754 reg_sampler_code = ins->src[1].reg.idx;
1756 /* 1.0-1.3: Use the texcoord varying.
1757 1.4+: Use provided coordinate source register. */
1758 if (shader_version < WINED3D_SHADER_VERSION(1,4))
1759 sprintf(reg_coord, "fragment.texcoord[%u]", reg_sampler_code);
1761 /* TEX is the only instruction that can handle DW and DZ natively */
1763 if(src.modifiers == WINED3DSPSM_DW) src.modifiers = WINED3DSPSM_NONE;
1764 if(src.modifiers == WINED3DSPSM_DZ) src.modifiers = WINED3DSPSM_NONE;
1765 shader_arb_get_src_param(ins, &src, 0, reg_coord);
1769 * 1.1, 1.2, 1.3: Use WINED3DTSS_TEXTURETRANSFORMFLAGS
1770 * 1.4: Use WINED3DSPSM_DZ or WINED3DSPSM_DW on src[0]
1771 * 2.0+: Use WINED3DSI_TEXLD_PROJECT on the opcode
1773 if (shader_version < WINED3D_SHADER_VERSION(1,4))
1776 if(reg_sampler_code < MAX_TEXTURES) {
1777 flags = deviceImpl->stateBlock->textureState[reg_sampler_code][WINED3DTSS_TEXTURETRANSFORMFLAGS];
1779 if (flags & WINED3DTTFF_PROJECTED) {
1780 myflags |= TEX_PROJ;
1783 else if (shader_version < WINED3D_SHADER_VERSION(2,0))
1785 DWORD src_mod = ins->src[0].modifiers;
1786 if (src_mod == WINED3DSPSM_DZ) {
1787 /* TXP cannot handle DZ natively, so move the z coordinate to .w. reg_coord is a read-only
1788 * varying register, so we need a temp reg
1790 shader_addline(ins->ctx->buffer, "SWZ TA, %s, x, y, z, z;\n", reg_coord);
1791 strcpy(reg_coord, "TA");
1792 myflags |= TEX_PROJ;
1793 } else if(src_mod == WINED3DSPSM_DW) {
1794 myflags |= TEX_PROJ;
1797 if (ins->flags & WINED3DSI_TEXLD_PROJECT) myflags |= TEX_PROJ;
1798 if (ins->flags & WINED3DSI_TEXLD_BIAS) myflags |= TEX_BIAS;
1800 shader_hw_sample(ins, reg_sampler_code, reg_dest, reg_coord, myflags, NULL, NULL);
1803 static void pshader_hw_texcoord(const struct wined3d_shader_instruction *ins)
1805 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1806 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1807 DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
1808 ins->ctx->reg_maps->shader_version.minor);
1811 if (shader_version < WINED3D_SHADER_VERSION(1,4))
1813 DWORD reg = dst->reg.idx;
1815 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
1816 shader_addline(buffer, "MOV_SAT %s, fragment.texcoord[%u];\n", dst_str, reg);
1820 shader_arb_get_src_param(ins, &ins->src[0], 0, reg_src);
1821 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
1822 shader_addline(buffer, "MOV %s, %s;\n", dst_str, reg_src);
1826 static void pshader_hw_texreg2ar(const struct wined3d_shader_instruction *ins)
1828 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1829 IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
1830 IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
1833 DWORD reg1 = ins->dst[0].reg.idx;
1837 /* Note that texreg2ar treats Tx as a temporary register, not as a varying */
1838 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
1839 shader_arb_get_src_param(ins, &ins->src[0], 0, src_str);
1840 /* Move .x first in case src_str is "TA" */
1841 shader_addline(buffer, "MOV TA.y, %s.x;\n", src_str);
1842 shader_addline(buffer, "MOV TA.x, %s.w;\n", src_str);
1843 flags = reg1 < MAX_TEXTURES ? deviceImpl->stateBlock->textureState[reg1][WINED3DTSS_TEXTURETRANSFORMFLAGS] : 0;
1844 shader_hw_sample(ins, reg1, dst_str, "TA", flags & WINED3DTTFF_PROJECTED ? TEX_PROJ : 0, NULL, NULL);
1847 static void pshader_hw_texreg2gb(const struct wined3d_shader_instruction *ins)
1849 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1851 DWORD reg1 = ins->dst[0].reg.idx;
1855 /* Note that texreg2gb treats Tx as a temporary register, not as a varying */
1856 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
1857 shader_arb_get_src_param(ins, &ins->src[0], 0, src_str);
1858 shader_addline(buffer, "MOV TA.x, %s.y;\n", src_str);
1859 shader_addline(buffer, "MOV TA.y, %s.z;\n", src_str);
1860 shader_hw_sample(ins, reg1, dst_str, "TA", 0, NULL, NULL);
1863 static void pshader_hw_texreg2rgb(const struct wined3d_shader_instruction *ins)
1865 DWORD reg1 = ins->dst[0].reg.idx;
1869 /* Note that texreg2rg treats Tx as a temporary register, not as a varying */
1870 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
1871 shader_arb_get_src_param(ins, &ins->src[0], 0, src_str);
1872 shader_hw_sample(ins, reg1, dst_str, src_str, 0, NULL, NULL);
1875 static void pshader_hw_texbem(const struct wined3d_shader_instruction *ins)
1877 IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
1878 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1879 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1880 char reg_coord[40], dst_reg[50], src_reg[50];
1881 DWORD reg_dest_code;
1883 /* All versions have a destination register. The Tx where the texture coordinates come
1884 * from is the varying incarnation of the texture register
1886 reg_dest_code = dst->reg.idx;
1887 shader_arb_get_dst_param(ins, &ins->dst[0], dst_reg);
1888 shader_arb_get_src_param(ins, &ins->src[0], 0, src_reg);
1889 sprintf(reg_coord, "fragment.texcoord[%u]", reg_dest_code);
1891 /* Sampling the perturbation map in Tsrc was done already, including the signedness correction if needed
1892 * The Tx in which the perturbation map is stored is the tempreg incarnation of the texture register
1894 * GL_NV_fragment_program_option could handle this in one instruction via X2D:
1895 * X2D TA.xy, fragment.texcoord, T%u, bumpenvmat%u.xzyw
1897 * However, the NV extensions are never enabled for <= 2.0 shaders because of the performance penalty that
1898 * comes with it, and texbem is an 1.x only instruction. No 1.x instruction forces us to enable the NV
1901 shader_addline(buffer, "SWZ TB, bumpenvmat%d, x, z, 0, 0;\n", reg_dest_code);
1902 shader_addline(buffer, "DP3 TA.x, TB, %s;\n", src_reg);
1903 shader_addline(buffer, "SWZ TB, bumpenvmat%d, y, w, 0, 0;\n", reg_dest_code);
1904 shader_addline(buffer, "DP3 TA.y, TB, %s;\n", src_reg);
1906 /* with projective textures, texbem only divides the static texture coord, not the displacement,
1907 * so we can't let the GL handle this.
1909 if (((IWineD3DDeviceImpl*) This->baseShader.device)->stateBlock->textureState[reg_dest_code][WINED3DTSS_TEXTURETRANSFORMFLAGS]
1910 & WINED3DTTFF_PROJECTED) {
1911 shader_addline(buffer, "RCP TB.w, %s.w;\n", reg_coord);
1912 shader_addline(buffer, "MUL TB.xy, %s, TB.w;\n", reg_coord);
1913 shader_addline(buffer, "ADD TA.xy, TA, TB;\n");
1915 shader_addline(buffer, "ADD TA.xy, TA, %s;\n", reg_coord);
1918 shader_hw_sample(ins, reg_dest_code, dst_reg, "TA", 0, NULL, NULL);
1920 if (ins->handler_idx == WINED3DSIH_TEXBEML)
1922 /* No src swizzles are allowed, so this is ok */
1923 shader_addline(buffer, "MAD TA, %s.z, luminance%d.x, luminance%d.y;\n",
1924 src_reg, reg_dest_code, reg_dest_code);
1925 shader_addline(buffer, "MUL %s, %s, TA;\n", dst_reg, dst_reg);
1929 static void pshader_hw_texm3x2pad(const struct wined3d_shader_instruction *ins)
1931 DWORD reg = ins->dst[0].reg.idx;
1932 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1933 char src0_name[50], dst_name[50];
1935 struct wined3d_shader_register tmp_reg = ins->dst[0].reg;
1937 shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
1938 /* The next instruction will be a texm3x2tex or texm3x2depth that writes to the uninitialized
1939 * T<reg+1> register. Use this register to store the calculated vector
1941 tmp_reg.idx = reg + 1;
1942 shader_arb_get_register_name(ins, &tmp_reg, dst_name, &is_color);
1943 shader_addline(buffer, "DP3 %s.x, fragment.texcoord[%u], %s;\n", dst_name, reg, src0_name);
1946 static void pshader_hw_texm3x2tex(const struct wined3d_shader_instruction *ins)
1948 IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
1949 IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
1951 DWORD reg = ins->dst[0].reg.idx;
1952 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1958 /* We know that we're writing to the uninitialized T<reg> register, so use it for temporary storage */
1959 shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_reg, &is_color);
1961 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
1962 shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
1963 shader_addline(buffer, "DP3 %s.y, fragment.texcoord[%u], %s;\n", dst_reg, reg, src0_name);
1964 flags = reg < MAX_TEXTURES ? deviceImpl->stateBlock->textureState[reg][WINED3DTSS_TEXTURETRANSFORMFLAGS] : 0;
1965 shader_hw_sample(ins, reg, dst_str, dst_reg, flags & WINED3DTTFF_PROJECTED ? TEX_PROJ : 0, NULL, NULL);
1968 static void pshader_hw_texm3x3pad(const struct wined3d_shader_instruction *ins)
1970 IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
1971 DWORD reg = ins->dst[0].reg.idx;
1972 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1973 SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
1974 char src0_name[50], dst_name[50];
1975 struct wined3d_shader_register tmp_reg = ins->dst[0].reg;
1978 /* There are always 2 texm3x3pad instructions followed by one texm3x3[tex,vspec, ...] instruction, with
1979 * incrementing ins->dst[0].register_idx numbers. So the pad instruction already knows the final destination
1980 * register, and this register is uninitialized(otherwise the assembler complains that it is 'redeclared')
1982 tmp_reg.idx = reg + 2 - current_state->current_row;
1983 shader_arb_get_register_name(ins, &tmp_reg, dst_name, &is_color);
1985 shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
1986 shader_addline(buffer, "DP3 %s.%c, fragment.texcoord[%u], %s;\n",
1987 dst_name, 'x' + current_state->current_row, reg, src0_name);
1988 current_state->texcoord_w[current_state->current_row++] = reg;
1991 static void pshader_hw_texm3x3tex(const struct wined3d_shader_instruction *ins)
1993 IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
1994 IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
1996 DWORD reg = ins->dst[0].reg.idx;
1997 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
1998 SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
2000 char src0_name[50], dst_name[50];
2003 shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_name, &is_color);
2004 shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
2005 shader_addline(buffer, "DP3 %s.z, fragment.texcoord[%u], %s;\n", dst_name, reg, src0_name);
2007 /* Sample the texture using the calculated coordinates */
2008 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
2009 flags = reg < MAX_TEXTURES ? deviceImpl->stateBlock->textureState[reg][WINED3DTSS_TEXTURETRANSFORMFLAGS] : 0;
2010 shader_hw_sample(ins, reg, dst_str, dst_name, flags & WINED3DTTFF_PROJECTED ? TEX_PROJ : 0, NULL, NULL);
2011 current_state->current_row = 0;
2014 static void pshader_hw_texm3x3vspec(const struct wined3d_shader_instruction *ins)
2016 IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
2017 IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
2019 DWORD reg = ins->dst[0].reg.idx;
2020 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2021 SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
2027 /* Get the dst reg without writemask strings. We know this register is uninitialized, so we can use all
2028 * components for temporary data storage
2030 shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_reg, &is_color);
2031 shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
2032 shader_addline(buffer, "DP3 %s.z, fragment.texcoord[%u], %s;\n", dst_reg, reg, src0_name);
2034 /* Construct the eye-ray vector from w coordinates */
2035 shader_addline(buffer, "MOV TB.x, fragment.texcoord[%u].w;\n", current_state->texcoord_w[0]);
2036 shader_addline(buffer, "MOV TB.y, fragment.texcoord[%u].w;\n", current_state->texcoord_w[1]);
2037 shader_addline(buffer, "MOV TB.z, fragment.texcoord[%u].w;\n", reg);
2039 /* Calculate reflection vector
2041 shader_addline(buffer, "DP3 %s.w, %s, TB;\n", dst_reg, dst_reg);
2042 /* The .w is ignored when sampling, so I can use TB.w to calculate dot(N, N) */
2043 shader_addline(buffer, "DP3 TB.w, %s, %s;\n", dst_reg, dst_reg);
2044 shader_addline(buffer, "RCP TB.w, TB.w;\n");
2045 shader_addline(buffer, "MUL %s.w, %s.w, TB.w;\n", dst_reg, dst_reg);
2046 shader_addline(buffer, "MUL %s, %s.w, %s;\n", dst_reg, dst_reg, dst_reg);
2047 shader_addline(buffer, "MAD %s, coefmul.x, %s, -TB;\n", dst_reg, dst_reg);
2049 /* Sample the texture using the calculated coordinates */
2050 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
2051 flags = reg < MAX_TEXTURES ? deviceImpl->stateBlock->textureState[reg][WINED3DTSS_TEXTURETRANSFORMFLAGS] : 0;
2052 shader_hw_sample(ins, reg, dst_str, dst_reg, flags & WINED3DTTFF_PROJECTED ? TEX_PROJ : 0, NULL, NULL);
2053 current_state->current_row = 0;
2056 static void pshader_hw_texm3x3spec(const struct wined3d_shader_instruction *ins)
2058 IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
2059 IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
2061 DWORD reg = ins->dst[0].reg.idx;
2062 SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
2063 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2070 shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
2071 shader_arb_get_src_param(ins, &ins->src[0], 1, src1_name);
2072 shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_reg, &is_color);
2073 /* Note: dst_reg.xy is input here, generated by two texm3x3pad instructions */
2074 shader_addline(buffer, "DP3 %s.z, fragment.texcoord[%u], %s;\n", dst_reg, reg, src0_name);
2076 /* Calculate reflection vector.
2079 * dst_reg.xyz = 2 * --------- * N - E
2082 * Which normalizes the normal vector
2084 shader_addline(buffer, "DP3 %s.w, %s, %s;\n", dst_reg, dst_reg, src1_name);
2085 shader_addline(buffer, "DP3 TC.w, %s, %s;\n", dst_reg, dst_reg);
2086 shader_addline(buffer, "RCP TC.w, TC.w;\n");
2087 shader_addline(buffer, "MUL %s.w, %s.w, TC.w;\n", dst_reg, dst_reg);
2088 shader_addline(buffer, "MUL %s, %s.w, %s;\n", dst_reg, dst_reg, dst_reg);
2089 shader_addline(buffer, "MAD %s, coefmul.x, %s, -%s;\n", dst_reg, dst_reg, src1_name);
2091 /* Sample the texture using the calculated coordinates */
2092 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
2093 flags = reg < MAX_TEXTURES ? deviceImpl->stateBlock->textureState[reg][WINED3DTSS_TEXTURETRANSFORMFLAGS] : 0;
2094 shader_hw_sample(ins, reg, dst_str, dst_reg, flags & WINED3DTTFF_PROJECTED ? TEX_PROJ : 0, NULL, NULL);
2095 current_state->current_row = 0;
2098 static void pshader_hw_texdepth(const struct wined3d_shader_instruction *ins)
2100 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
2101 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2104 /* texdepth has an implicit destination, the fragment depth value. It's only parameter,
2105 * which is essentially an input, is the destination register because it is the first
2106 * parameter. According to the msdn, this must be register r5, but let's keep it more flexible
2107 * here(writemasks/swizzles are not valid on texdepth)
2109 shader_arb_get_dst_param(ins, dst, dst_name);
2111 /* According to the msdn, the source register(must be r5) is unusable after
2112 * the texdepth instruction, so we're free to modify it
2114 shader_addline(buffer, "MIN %s.y, %s.y, one.y;\n", dst_name, dst_name);
2116 /* How to deal with the special case dst_name.g == 0? if r != 0, then
2117 * the r * (1 / 0) will give infinity, which is clamped to 1.0, the correct
2118 * result. But if r = 0.0, then 0 * inf = 0, which is incorrect.
2120 shader_addline(buffer, "RCP %s.y, %s.y;\n", dst_name, dst_name);
2121 shader_addline(buffer, "MUL TA.x, %s.x, %s.y;\n", dst_name, dst_name);
2122 shader_addline(buffer, "MIN TA.x, TA.x, one.x;\n");
2123 shader_addline(buffer, "MAX result.depth, TA.x, 0.0;\n");
2126 /** Process the WINED3DSIO_TEXDP3TEX instruction in ARB:
2127 * Take a 3-component dot product of the TexCoord[dstreg] and src,
2128 * then perform a 1D texture lookup from stage dstregnum, place into dst. */
2129 static void pshader_hw_texdp3tex(const struct wined3d_shader_instruction *ins)
2131 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2132 DWORD sampler_idx = ins->dst[0].reg.idx;
2136 shader_arb_get_src_param(ins, &ins->src[0], 0, src0);
2137 shader_addline(buffer, "MOV TB, 0.0;\n");
2138 shader_addline(buffer, "DP3 TB.x, fragment.texcoord[%u], %s;\n", sampler_idx, src0);
2140 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
2141 shader_hw_sample(ins, sampler_idx, dst_str, "TB", 0 /* Only one coord, can't be projected */, NULL, NULL);
2144 /** Process the WINED3DSIO_TEXDP3 instruction in ARB:
2145 * Take a 3-component dot product of the TexCoord[dstreg] and src. */
2146 static void pshader_hw_texdp3(const struct wined3d_shader_instruction *ins)
2148 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
2151 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2153 /* Handle output register */
2154 shader_arb_get_dst_param(ins, dst, dst_str);
2155 shader_arb_get_src_param(ins, &ins->src[0], 0, src0);
2156 shader_addline(buffer, "DP3 %s, fragment.texcoord[%u], %s;\n", dst_str, dst->reg.idx, src0);
2159 /** Process the WINED3DSIO_TEXM3X3 instruction in ARB
2160 * Perform the 3rd row of a 3x3 matrix multiply */
2161 static void pshader_hw_texm3x3(const struct wined3d_shader_instruction *ins)
2163 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
2164 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2165 char dst_str[50], dst_name[50];
2169 shader_arb_get_dst_param(ins, dst, dst_str);
2170 shader_arb_get_src_param(ins, &ins->src[0], 0, src0);
2171 shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_name, &is_color);
2172 shader_addline(buffer, "DP3 %s.z, fragment.texcoord[%u], %s;\n", dst_name, dst->reg.idx, src0);
2173 shader_addline(buffer, "MOV %s, %s;\n", dst_str, dst_name);
2176 /** Process the WINED3DSIO_TEXM3X2DEPTH instruction in ARB:
2177 * Last row of a 3x2 matrix multiply, use the result to calculate the depth:
2178 * Calculate tmp0.y = TexCoord[dstreg] . src.xyz; (tmp0.x has already been calculated)
2179 * depth = (tmp0.y == 0.0) ? 1.0 : tmp0.x / tmp0.y
2181 static void pshader_hw_texm3x2depth(const struct wined3d_shader_instruction *ins)
2183 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2184 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
2185 char src0[50], dst_name[50];
2188 shader_arb_get_src_param(ins, &ins->src[0], 0, src0);
2189 shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_name, &is_color);
2190 shader_addline(buffer, "DP3 %s.y, fragment.texcoord[%u], %s;\n", dst_name, dst->reg.idx, src0);
2192 /* How to deal with the special case dst_name.g == 0? if r != 0, then
2193 * the r * (1 / 0) will give infinity, which is clamped to 1.0, the correct
2194 * result. But if r = 0.0, then 0 * inf = 0, which is incorrect.
2196 shader_addline(buffer, "RCP %s.y, %s.y;\n", dst_name, dst_name);
2197 shader_addline(buffer, "MUL %s.x, %s.x, %s.y;\n", dst_name, dst_name, dst_name);
2198 shader_addline(buffer, "MIN %s.x, %s.x, one.x;\n", dst_name, dst_name);
2199 shader_addline(buffer, "MAX result.depth, %s.x, 0.0;\n", dst_name);
2202 /** Handles transforming all WINED3DSIO_M?x? opcodes for
2203 Vertex/Pixel shaders to ARB_vertex_program codes */
2204 static void shader_hw_mnxn(const struct wined3d_shader_instruction *ins)
2207 int nComponents = 0;
2208 struct wined3d_shader_dst_param tmp_dst = {{0}};
2209 struct wined3d_shader_src_param tmp_src[2] = {{{0}}};
2210 struct wined3d_shader_instruction tmp_ins;
2212 memset(&tmp_ins, 0, sizeof(tmp_ins));
2214 /* Set constants for the temporary argument */
2215 tmp_ins.ctx = ins->ctx;
2216 tmp_ins.dst_count = 1;
2217 tmp_ins.dst = &tmp_dst;
2218 tmp_ins.src_count = 2;
2219 tmp_ins.src = tmp_src;
2221 switch(ins->handler_idx)
2223 case WINED3DSIH_M4x4:
2225 tmp_ins.handler_idx = WINED3DSIH_DP4;
2227 case WINED3DSIH_M4x3:
2229 tmp_ins.handler_idx = WINED3DSIH_DP4;
2231 case WINED3DSIH_M3x4:
2233 tmp_ins.handler_idx = WINED3DSIH_DP3;
2235 case WINED3DSIH_M3x3:
2237 tmp_ins.handler_idx = WINED3DSIH_DP3;
2239 case WINED3DSIH_M3x2:
2241 tmp_ins.handler_idx = WINED3DSIH_DP3;
2244 FIXME("Unhandled opcode %#x\n", ins->handler_idx);
2248 tmp_dst = ins->dst[0];
2249 tmp_src[0] = ins->src[0];
2250 tmp_src[1] = ins->src[1];
2251 for (i = 0; i < nComponents; i++) {
2252 tmp_dst.write_mask = WINED3DSP_WRITEMASK_0 << i;
2253 shader_hw_map2gl(&tmp_ins);
2254 ++tmp_src[1].reg.idx;
2258 static void shader_hw_rsq_rcp(const struct wined3d_shader_instruction *ins)
2260 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2261 const char *instruction;
2266 switch(ins->handler_idx)
2268 case WINED3DSIH_RSQ: instruction = "RSQ"; break;
2269 case WINED3DSIH_RCP: instruction = "RCP"; break;
2270 default: instruction = "";
2271 FIXME("Unhandled opcode %#x\n", ins->handler_idx);
2275 shader_arb_get_dst_param(ins, &ins->dst[0], dst); /* Destination */
2276 shader_arb_get_src_param(ins, &ins->src[0], 0, src);
2277 if (ins->src[0].swizzle == WINED3DSP_NOSWIZZLE)
2279 /* Dx sdk says .x is used if no swizzle is given, but our test shows that
2285 shader_addline(buffer, "%s%s %s, %s;\n", instruction, shader_arb_get_modifier(ins), dst, src);
2288 static void shader_hw_nrm(const struct wined3d_shader_instruction *ins)
2290 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2293 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2294 BOOL pshader = shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type);
2296 shader_arb_get_dst_param(ins, &ins->dst[0], dst_name);
2297 shader_arb_get_src_param(ins, &ins->src[0], 1 /* Use TB */, src_name);
2299 if(pshader && priv->target_version >= NV3)
2301 shader_addline(buffer, "NRM%s %s, %s;\n", shader_arb_get_modifier(ins), dst_name, src_name);
2305 shader_addline(buffer, "DP3 TA, %s, %s;\n", src_name, src_name);
2306 shader_addline(buffer, "RSQ TA, TA.x;\n");
2307 /* dst.w = src[0].w * 1 / (src.x^2 + src.y^2 + src.z^2)^(1/2) according to msdn*/
2308 shader_addline(buffer, "MUL%s %s, %s, TA;\n", shader_arb_get_modifier(ins), dst_name,
2313 static void shader_hw_lrp(const struct wined3d_shader_instruction *ins)
2315 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2317 char src_name[3][50];
2319 /* ARB_fragment_program has a convenient LRP instruction */
2320 if(shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type)) {
2321 shader_hw_map2gl(ins);
2325 shader_arb_get_dst_param(ins, &ins->dst[0], dst_name);
2326 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name[0]);
2327 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
2328 shader_arb_get_src_param(ins, &ins->src[2], 2, src_name[2]);
2330 shader_addline(buffer, "SUB TA, %s, %s;\n", src_name[1], src_name[2]);
2331 shader_addline(buffer, "MAD%s %s, %s, TA, %s;\n", shader_arb_get_modifier(ins),
2332 dst_name, src_name[0], src_name[2]);
2335 static void shader_hw_sincos(const struct wined3d_shader_instruction *ins)
2337 /* This instruction exists in ARB, but the d3d instruction takes two extra parameters which
2338 * must contain fixed constants. So we need a separate function to filter those constants and
2341 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2342 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2343 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
2345 char src_name0[50], src_name1[50], src_name2[50];
2348 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name0);
2349 if(shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type)) {
2350 shader_arb_get_dst_param(ins, &ins->dst[0], dst_name);
2351 /* No modifiers are supported on SCS */
2352 shader_addline(buffer, "SCS %s, %s;\n", dst_name, src_name0);
2354 if(ins->dst[0].modifiers & WINED3DSPDM_SATURATE)
2356 shader_arb_get_register_name(ins, &dst->reg, src_name0, &is_color);
2357 shader_addline(buffer, "MOV_SAT %s, %s;\n", dst_name, src_name0);
2359 } else if(priv->target_version >= NV2) {
2360 shader_arb_get_register_name(ins, &dst->reg, dst_name, &is_color);
2362 /* Sincos writemask must be .x, .y or .xy */
2363 if(dst->write_mask & WINED3DSP_WRITEMASK_0)
2364 shader_addline(buffer, "COS%s %s.x, %s;\n", shader_arb_get_modifier(ins), dst_name, src_name0);
2365 if(dst->write_mask & WINED3DSP_WRITEMASK_1)
2366 shader_addline(buffer, "SIN%s %s.y, %s;\n", shader_arb_get_modifier(ins), dst_name, src_name0);
2368 /* Approximate sine and cosine with a taylor series, as per math textbook. The application passes 8
2369 * helper constants(D3DSINCOSCONST1 and D3DSINCOSCONST2) in src1 and src2.
2371 * sin(x) = x - x^3/3! + x^5/5! - x^7/7! + ...
2372 * cos(x) = 1 - x^2/2! + x^4/4! - x^6/6! + ...
2374 * The constants we get are:
2376 * +1 +1, -1 -1 +1 +1 -1 -1
2377 * ---- , ---- , ---- , ----- , ----- , ----- , ------
2378 * 1!*2 2!*4 3!*8 4!*16 5!*32 6!*64 7!*128
2380 * If used with x^2, x^3, x^4 etc they calculate sin(x/2) and cos(x/2):
2384 * (x/2)^4 = x^4 / 16
2385 * (x/2)^5 = x^5 / 32
2388 * To get the final result:
2389 * sin(x) = 2 * sin(x/2) * cos(x/2)
2390 * cos(x) = cos(x/2)^2 - sin(x/2)^2
2391 * (from sin(x+y) and cos(x+y) rules)
2393 * As per MSDN, dst.z is undefined after the operation, and so is
2394 * dst.x and dst.y if they're masked out by the writemask. Ie
2395 * sincos dst.y, src1, c0, c1
2396 * returns the sine in dst.y. dst.x and dst.z are undefined, dst.w is not touched. The assembler
2397 * vsa.exe also stops with an error if the dest register is the same register as the source
2398 * register. This means we can use dest.xyz as temporary storage. The assembler vsa.exe output also
2399 * indicates that sincos consumes 8 instruction slots in vs_2_0(and, strangely, in vs_3_0).
2401 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name1);
2402 shader_arb_get_src_param(ins, &ins->src[2], 2, src_name2);
2403 shader_arb_get_register_name(ins, &dst->reg, dst_name, &is_color);
2405 shader_addline(buffer, "MUL %s.x, %s, %s;\n", dst_name, src_name0, src_name0); /* x ^ 2 */
2406 shader_addline(buffer, "MUL TA.y, %s.x, %s;\n", dst_name, src_name0); /* x ^ 3 */
2407 shader_addline(buffer, "MUL %s.y, TA.y, %s;\n", dst_name, src_name0); /* x ^ 4 */
2408 shader_addline(buffer, "MUL TA.z, %s.y, %s;\n", dst_name, src_name0); /* x ^ 5 */
2409 shader_addline(buffer, "MUL %s.z, TA.z, %s;\n", dst_name, src_name0); /* x ^ 6 */
2410 shader_addline(buffer, "MUL TA.w, %s.z, %s;\n", dst_name, src_name0); /* x ^ 7 */
2414 * Unfortunately we don't get the constants in a DP4-capable form. Is there a way to
2415 * properly merge that with MULs in the code above?
2416 * The swizzles .yz and xw however fit into the .yzxw swizzle added to ps_2_0. Maybe
2417 * we can merge the sine and cosine MAD rows to calculate them together.
2419 shader_addline(buffer, "MUL TA.x, %s, %s.w;\n", src_name0, src_name2); /* x^1, +1/(1!*2) */
2420 shader_addline(buffer, "MAD TA.x, TA.y, %s.x, TA.x;\n", src_name2); /* -1/(3!*8) */
2421 shader_addline(buffer, "MAD TA.x, TA.z, %s.w, TA.x;\n", src_name1); /* +1/(5!*32) */
2422 shader_addline(buffer, "MAD TA.x, TA.w, %s.x, TA.x;\n", src_name1); /* -1/(7!*128) */
2425 shader_addline(buffer, "MAD TA.y, %s.x, %s.y, %s.z;\n", dst_name, src_name2, src_name2); /* -1/(2!*4), +1.0 */
2426 shader_addline(buffer, "MAD TA.y, %s.y, %s.z, TA.y;\n", dst_name, src_name1); /* +1/(4!*16) */
2427 shader_addline(buffer, "MAD TA.y, %s.z, %s.y, TA.y;\n", dst_name, src_name1); /* -1/(6!*64) */
2429 if(dst->write_mask & WINED3DSP_WRITEMASK_0) {
2431 shader_addline(buffer, "MUL TA.z, TA.y, TA.y;\n");
2432 shader_addline(buffer, "MAD %s.x, -TA.x, TA.x, TA.z;\n", dst_name);
2434 if(dst->write_mask & WINED3DSP_WRITEMASK_1) {
2436 shader_addline(buffer, "MUL %s.y, TA.x, TA.y;\n", dst_name);
2437 shader_addline(buffer, "ADD %s.y, %s.y, %s.y;\n", dst_name, dst_name, dst_name);
2442 static void shader_hw_sgn(const struct wined3d_shader_instruction *ins)
2444 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2447 struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
2449 /* SGN is only valid in vertex shaders */
2450 if(ctx->target_version == NV2) {
2451 shader_hw_map2gl(ins);
2454 shader_arb_get_dst_param(ins, &ins->dst[0], dst_name);
2455 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name);
2457 /* If SRC > 0.0, -SRC < SRC = TRUE, otherwise false.
2458 * if SRC < 0.0, SRC < -SRC = TRUE. If neither is true, src = 0.0
2460 if(ins->dst[0].modifiers & WINED3DSPDM_SATURATE) {
2461 shader_addline(buffer, "SLT %s, -%s, %s;\n", dst_name, src_name, src_name);
2463 /* src contains TA? Write to the dest first. This won't overwrite our destination.
2464 * Then use TA, and calculate the final result
2466 * Not reading from TA? Store the first result in TA to avoid overwriting the
2467 * destination if src reg = dst reg
2469 if(strstr(src_name, "TA"))
2471 shader_addline(buffer, "SLT %s, %s, -%s;\n", dst_name, src_name, src_name);
2472 shader_addline(buffer, "SLT TA, -%s, %s;\n", src_name, src_name);
2473 shader_addline(buffer, "ADD %s, %s, -TA;\n", dst_name, dst_name);
2477 shader_addline(buffer, "SLT TA, -%s, %s;\n", src_name, src_name);
2478 shader_addline(buffer, "SLT %s, %s, -%s;\n", dst_name, src_name, src_name);
2479 shader_addline(buffer, "ADD %s, TA, -%s;\n", dst_name, dst_name);
2484 static void shader_hw_dsy(const struct wined3d_shader_instruction *ins)
2486 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2492 shader_arb_get_dst_param(ins, &ins->dst[0], dst);
2493 shader_arb_get_src_param(ins, &ins->src[0], 0, src);
2494 shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_name, &is_color);
2496 shader_addline(buffer, "DDY %s, %s;\n", dst, src);
2497 shader_addline(buffer, "MUL%s %s, %s, ycorrection.y;\n", shader_arb_get_modifier(ins), dst, dst_name);
2500 static DWORD abs_modifier(DWORD mod, BOOL *need_abs)
2506 case WINED3DSPSM_NONE: return WINED3DSPSM_ABS;
2507 case WINED3DSPSM_NEG: return WINED3DSPSM_ABS;
2508 case WINED3DSPSM_BIAS: *need_abs = TRUE; return WINED3DSPSM_BIAS;
2509 case WINED3DSPSM_BIASNEG: *need_abs = TRUE; return WINED3DSPSM_BIASNEG;
2510 case WINED3DSPSM_SIGN: *need_abs = TRUE; return WINED3DSPSM_SIGN;
2511 case WINED3DSPSM_SIGNNEG: *need_abs = TRUE; return WINED3DSPSM_SIGNNEG;
2512 case WINED3DSPSM_COMP: *need_abs = TRUE; return WINED3DSPSM_COMP;
2513 case WINED3DSPSM_X2: *need_abs = TRUE; return WINED3DSPSM_X2;
2514 case WINED3DSPSM_X2NEG: *need_abs = TRUE; return WINED3DSPSM_X2NEG;
2515 case WINED3DSPSM_DZ: *need_abs = TRUE; return WINED3DSPSM_DZ;
2516 case WINED3DSPSM_DW: *need_abs = TRUE; return WINED3DSPSM_DW;
2517 case WINED3DSPSM_ABS: return WINED3DSPSM_ABS;
2518 case WINED3DSPSM_ABSNEG: return WINED3DSPSM_ABS;
2520 FIXME("Unknown modifier %u\n", mod);
2524 static void shader_hw_log_pow(const struct wined3d_shader_instruction *ins)
2526 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2527 char src0[50], src1[50], dst[50];
2528 struct wined3d_shader_src_param src0_copy = ins->src[0];
2529 BOOL need_abs = FALSE;
2533 switch(ins->handler_idx)
2535 case WINED3DSIH_LOG: instr = "LG2"; break;
2536 case WINED3DSIH_LOGP: instr = "LOG"; break;
2537 case WINED3DSIH_POW: instr = "POW"; arg2 = TRUE; break;
2539 ERR("Unexpected instruction %d\n", ins->handler_idx);
2543 /* LOG, LOGP and POW operate on the absolute value of the input */
2544 src0_copy.modifiers = abs_modifier(src0_copy.modifiers, &need_abs);
2546 shader_arb_get_dst_param(ins, &ins->dst[0], dst);
2547 shader_arb_get_src_param(ins, &src0_copy, 0, src0);
2548 if(arg2) shader_arb_get_src_param(ins, &ins->src[1], 1, src1);
2552 shader_addline(buffer, "ABS TA, %s;\n", src0);
2555 shader_addline(buffer, "%s%s %s, TA, %s;\n", instr, shader_arb_get_modifier(ins), dst, src1);
2559 shader_addline(buffer, "%s%s %s, TA;\n", instr, shader_arb_get_modifier(ins), dst);
2564 shader_addline(buffer, "%s%s %s, %s, %s;\n", instr, shader_arb_get_modifier(ins), dst, src0, src1);
2568 shader_addline(buffer, "%s%s %s, %s;\n", instr, shader_arb_get_modifier(ins), dst, src0);
2572 static void shader_hw_loop(const struct wined3d_shader_instruction *ins)
2574 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2576 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2579 shader_arb_get_src_param(ins, &ins->src[1], 0, src_name);
2583 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2584 struct list *e = list_head(&priv->control_frames);
2585 struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
2587 if(priv->loop_depth > 1) shader_addline(buffer, "PUSHA aL;\n");
2588 /* The constant loader makes sure to load -1 into iX.w */
2589 shader_addline(buffer, "ARLC aL, %s.xywz;\n", src_name);
2590 shader_addline(buffer, "BRA loop_%u_end (LE.x);\n", control_frame->loop_no);
2591 shader_addline(buffer, "loop_%u_start:\n", control_frame->loop_no);
2595 shader_addline(buffer, "LOOP %s;\n", src_name);
2599 static void shader_hw_rep(const struct wined3d_shader_instruction *ins)
2601 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2603 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2605 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name);
2607 /* The constant loader makes sure to load -1 into iX.w */
2610 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2611 struct list *e = list_head(&priv->control_frames);
2612 struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
2614 if(priv->loop_depth > 1) shader_addline(buffer, "PUSHA aL;\n");
2616 shader_addline(buffer, "ARLC aL, %s.xywz;\n", src_name);
2617 shader_addline(buffer, "BRA loop_%u_end (LE.x);\n", control_frame->loop_no);
2618 shader_addline(buffer, "loop_%u_start:\n", control_frame->loop_no);
2622 shader_addline(buffer, "REP %s;\n", src_name);
2626 static void shader_hw_endloop(const struct wined3d_shader_instruction *ins)
2628 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2629 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2633 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2634 struct list *e = list_head(&priv->control_frames);
2635 struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
2637 shader_addline(buffer, "ARAC aL.xy, aL;\n");
2638 shader_addline(buffer, "BRA loop_%u_start (GT.x);\n", control_frame->loop_no);
2639 shader_addline(buffer, "loop_%u_end:\n", control_frame->loop_no);
2641 if(priv->loop_depth > 1) shader_addline(buffer, "POPA aL;\n");
2645 shader_addline(buffer, "ENDLOOP;\n");
2649 static void shader_hw_endrep(const struct wined3d_shader_instruction *ins)
2651 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2652 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2656 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2657 struct list *e = list_head(&priv->control_frames);
2658 struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
2660 shader_addline(buffer, "ARAC aL.xy, aL;\n");
2661 shader_addline(buffer, "BRA loop_%u_start (GT.x);\n", control_frame->loop_no);
2662 shader_addline(buffer, "loop_%u_end:\n", control_frame->loop_no);
2664 if(priv->loop_depth > 1) shader_addline(buffer, "POPA aL;\n");
2668 shader_addline(buffer, "ENDREP;\n");
2672 static const struct control_frame *find_last_loop(const struct shader_arb_ctx_priv *priv)
2674 struct control_frame *control_frame;
2676 LIST_FOR_EACH_ENTRY(control_frame, &priv->control_frames, struct control_frame, entry)
2678 if(control_frame->type == LOOP || control_frame->type == REP) return control_frame;
2680 ERR("Could not find loop for break\n");
2684 static void shader_hw_break(const struct wined3d_shader_instruction *ins)
2686 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2687 const struct control_frame *control_frame = find_last_loop(ins->ctx->backend_data);
2688 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2692 shader_addline(buffer, "BRA loop_%u_end;\n", control_frame->loop_no);
2696 shader_addline(buffer, "BRK;\n");
2700 static const char *get_compare(COMPARISON_TYPE flags)
2704 case COMPARISON_GT: return "GT";
2705 case COMPARISON_EQ: return "EQ";
2706 case COMPARISON_GE: return "GE";
2707 case COMPARISON_LT: return "LT";
2708 case COMPARISON_NE: return "NE";
2709 case COMPARISON_LE: return "LE";
2711 FIXME("Unrecognized comparison value: %u\n", flags);
2716 static COMPARISON_TYPE invert_compare(COMPARISON_TYPE flags)
2720 case COMPARISON_GT: return COMPARISON_LE;
2721 case COMPARISON_EQ: return COMPARISON_NE;
2722 case COMPARISON_GE: return COMPARISON_LT;
2723 case COMPARISON_LT: return COMPARISON_GE;
2724 case COMPARISON_NE: return COMPARISON_EQ;
2725 case COMPARISON_LE: return COMPARISON_GT;
2727 FIXME("Unrecognized comparison value: %u\n", flags);
2732 static void shader_hw_breakc(const struct wined3d_shader_instruction *ins)
2734 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2735 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2736 const struct control_frame *control_frame = find_last_loop(ins->ctx->backend_data);
2739 const char *comp = get_compare(ins->flags);
2741 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name0);
2742 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name1);
2746 /* SUBC CC, src0, src1" works only in pixel shaders, so use TA to throw
2747 * away the subtraction result
2749 shader_addline(buffer, "SUBC TA, %s, %s;\n", src_name0, src_name1);
2750 shader_addline(buffer, "BRA loop_%u_end (%s.x);\n", control_frame->loop_no, comp);
2754 shader_addline(buffer, "SUBC TA, %s, %s;\n", src_name0, src_name1);
2755 shader_addline(buffer, "BRK (%s.x);\n", comp);
2759 static void shader_hw_ifc(const struct wined3d_shader_instruction *ins)
2761 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2762 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2763 struct list *e = list_head(&priv->control_frames);
2764 struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
2768 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2770 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name0);
2771 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name1);
2775 /* Invert the flag. We jump to the else label if the condition is NOT true */
2776 comp = get_compare(invert_compare(ins->flags));
2777 shader_addline(buffer, "SUBC TA, %s, %s;\n", src_name0, src_name1);
2778 shader_addline(buffer, "BRA ifc_%u_else (%s.x);\n", control_frame->ifc_no, comp);
2782 comp = get_compare(ins->flags);
2783 shader_addline(buffer, "SUBC TA, %s, %s;\n", src_name0, src_name1);
2784 shader_addline(buffer, "IF %s.x;\n", comp);
2788 static void shader_hw_else(const struct wined3d_shader_instruction *ins)
2790 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2791 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2792 struct list *e = list_head(&priv->control_frames);
2793 struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
2794 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2798 shader_addline(buffer, "BRA ifc_%u_endif;\n", control_frame->ifc_no);
2799 shader_addline(buffer, "ifc_%u_else:\n", control_frame->ifc_no);
2800 control_frame->had_else = TRUE;
2804 shader_addline(buffer, "ELSE;\n");
2808 static void shader_hw_endif(const struct wined3d_shader_instruction *ins)
2810 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2811 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2812 struct list *e = list_head(&priv->control_frames);
2813 struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
2814 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2818 if(control_frame->had_else)
2820 shader_addline(buffer, "ifc_%u_endif:\n", control_frame->ifc_no);
2824 shader_addline(buffer, "#No else branch. else is endif\n");
2825 shader_addline(buffer, "ifc_%u_else:\n", control_frame->ifc_no);
2830 shader_addline(buffer, "ENDIF;\n");
2834 static void shader_hw_texldd(const struct wined3d_shader_instruction *ins)
2836 DWORD sampler_idx = ins->src[1].reg.idx;
2838 char reg_src[3][40];
2839 DWORD flags = TEX_DERIV;
2841 shader_arb_get_dst_param(ins, &ins->dst[0], reg_dest);
2842 shader_arb_get_src_param(ins, &ins->src[0], 0, reg_src[0]);
2843 shader_arb_get_src_param(ins, &ins->src[2], 1, reg_src[1]);
2844 shader_arb_get_src_param(ins, &ins->src[3], 2, reg_src[2]);
2846 if (ins->flags & WINED3DSI_TEXLD_PROJECT) flags |= TEX_PROJ;
2847 if (ins->flags & WINED3DSI_TEXLD_BIAS) flags |= TEX_BIAS;
2849 shader_hw_sample(ins, sampler_idx, reg_dest, reg_src[0], flags, reg_src[1], reg_src[2]);
2852 static void shader_hw_texldl(const struct wined3d_shader_instruction *ins)
2854 DWORD sampler_idx = ins->src[1].reg.idx;
2857 DWORD flags = TEX_LOD;
2859 shader_arb_get_dst_param(ins, &ins->dst[0], reg_dest);
2860 shader_arb_get_src_param(ins, &ins->src[0], 0, reg_coord);
2862 if (ins->flags & WINED3DSI_TEXLD_PROJECT) flags |= TEX_PROJ;
2863 if (ins->flags & WINED3DSI_TEXLD_BIAS) flags |= TEX_BIAS;
2865 shader_hw_sample(ins, sampler_idx, reg_dest, reg_coord, flags, NULL, NULL);
2868 static void shader_hw_label(const struct wined3d_shader_instruction *ins)
2870 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2871 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2873 priv->in_main_func = FALSE;
2874 /* Call instructions activate the NV extensions, not labels and rets. If there is an uncalled
2875 * subroutine, don't generate a label that will make GL complain
2877 if(priv->target_version == ARB) return;
2879 shader_addline(buffer, "l%u:\n", ins->src[0].reg.idx);
2882 static void vshader_add_footer(IWineD3DVertexShaderImpl *This, struct wined3d_shader_buffer *buffer,
2883 const struct arb_vs_compile_args *args, struct shader_arb_ctx_priv *priv_ctx)
2885 const shader_reg_maps *reg_maps = &This->baseShader.reg_maps;
2886 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *)This->baseShader.device;
2887 const WineD3D_GL_Info *gl_info = &device->adapter->gl_info;
2890 /* The D3DRS_FOGTABLEMODE render state defines if the shader-generated fog coord is used
2891 * or if the fragment depth is used. If the fragment depth is used(FOGTABLEMODE != NONE),
2892 * the fog frag coord is thrown away. If the fog frag coord is used, but not written by
2893 * the shader, it is set to 0.0(fully fogged, since start = 1.0, end = 0.0)
2895 if(args->super.fog_src == VS_FOG_Z) {
2896 shader_addline(buffer, "MOV result.fogcoord, TMP_OUT.z;\n");
2897 } else if (!reg_maps->fog) {
2898 /* posFixup.x is always 1.0, so we can savely use it */
2899 shader_addline(buffer, "ADD result.fogcoord, posFixup.x, -posFixup.x;\n");
2902 /* Write the final position.
2904 * OpenGL coordinates specify the center of the pixel while d3d coords specify
2905 * the corner. The offsets are stored in z and w in posFixup. posFixup.y contains
2906 * 1.0 or -1.0 to turn the rendering upside down for offscreen rendering. PosFixup.x
2907 * contains 1.0 to allow a mad, but arb vs swizzles are too restricted for that.
2909 shader_addline(buffer, "MUL TA, posFixup, TMP_OUT.w;\n");
2910 shader_addline(buffer, "ADD TMP_OUT.x, TMP_OUT.x, TA.z;\n");
2911 shader_addline(buffer, "MAD TMP_OUT.y, TMP_OUT.y, posFixup.y, TA.w;\n");
2913 if(use_nv_clip(gl_info) && priv_ctx->target_version >= NV2)
2915 for(i = 0; i < priv_ctx->vs_clipplanes; i++)
2917 shader_addline(buffer, "DP4 result.clip[%u].x, TMP_OUT, state.clip[%u].plane;\n", i, i);
2920 else if(args->boolclip.clip_control[0])
2922 unsigned int cur_clip = 0;
2923 char component[4] = {'x', 'y', 'z', 'w'};
2925 for(i = 0; i < GL_LIMITS(clipplanes); i++)
2927 if(args->boolclip.clip_control[1] & (1 << i))
2929 shader_addline(buffer, "DP4 TA.%c, TMP_OUT, state.clip[%u].plane;\n",
2930 component[cur_clip++], i);
2936 shader_addline(buffer, "MOV TA, -helper_const.w;\n");
2939 shader_addline(buffer, "MOV TA.yzw, -helper_const.w;\n");
2942 shader_addline(buffer, "MOV TA.zw, -helper_const.w;\n");
2945 shader_addline(buffer, "MOV TA.w, -helper_const.w;\n");
2948 shader_addline(buffer, "MOV result.texcoord[%u], TA;\n",
2949 args->boolclip.clip_control[0] - 1);
2952 /* Z coord [0;1]->[-1;1] mapping, see comment in transform_projection in state.c
2953 * and the glsl equivalent
2955 if(need_helper_const(gl_info)) {
2956 shader_addline(buffer, "MAD TMP_OUT.z, TMP_OUT.z, helper_const.x, -TMP_OUT.w;\n");
2958 shader_addline(buffer, "ADD TMP_OUT.z, TMP_OUT.z, TMP_OUT.z;\n");
2959 shader_addline(buffer, "ADD TMP_OUT.z, TMP_OUT.z, -TMP_OUT.w;\n");
2962 shader_addline(buffer, "MOV result.position, TMP_OUT;\n");
2964 priv_ctx->footer_written = TRUE;
2967 static void shader_hw_ret(const struct wined3d_shader_instruction *ins)
2969 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2970 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2971 IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *) ins->ctx->shader;
2972 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2974 if(priv->target_version == ARB) return;
2978 if(priv->in_main_func) vshader_add_footer((IWineD3DVertexShaderImpl *) shader, buffer, priv->cur_vs_args, priv);
2981 shader_addline(buffer, "RET;\n");
2984 static void shader_hw_call(const struct wined3d_shader_instruction *ins)
2986 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2987 shader_addline(buffer, "CAL l%u;\n", ins->src[0].reg.idx);
2990 /* GL locking is done by the caller */
2991 static GLuint create_arb_blt_vertex_program(const WineD3D_GL_Info *gl_info)
2993 GLuint program_id = 0;
2994 const char *blt_vprogram =
2996 "PARAM c[1] = { { 1, 0.5 } };\n"
2997 "MOV result.position, vertex.position;\n"
2998 "MOV result.color, c[0].x;\n"
2999 "MOV result.texcoord[0], vertex.texcoord[0];\n"
3002 GL_EXTCALL(glGenProgramsARB(1, &program_id));
3003 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, program_id));
3004 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(blt_vprogram), blt_vprogram));
3006 if (glGetError() == GL_INVALID_OPERATION) {
3008 glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
3009 FIXME("Vertex program error at position %d: %s\n", pos,
3010 debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
3016 /* GL locking is done by the caller */
3017 static GLuint create_arb_blt_fragment_program(const WineD3D_GL_Info *gl_info, enum tex_types tex_type)
3019 GLuint program_id = 0;
3020 static const char * const blt_fprograms[tex_type_count] =
3027 "TEX R0.x, fragment.texcoord[0], texture[0], 2D;\n"
3028 "MOV result.depth.z, R0.x;\n"
3035 "TEX R0.x, fragment.texcoord[0], texture[0], CUBE;\n"
3036 "MOV result.depth.z, R0.x;\n"
3041 "TEX R0.x, fragment.texcoord[0], texture[0], RECT;\n"
3042 "MOV result.depth.z, R0.x;\n"
3046 if (!blt_fprograms[tex_type])
3048 FIXME("tex_type %#x not supported\n", tex_type);
3052 GL_EXTCALL(glGenProgramsARB(1, &program_id));
3053 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, program_id));
3054 GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(blt_fprograms[tex_type]), blt_fprograms[tex_type]));
3056 if (glGetError() == GL_INVALID_OPERATION) {
3058 glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
3059 FIXME("Fragment program error at position %d: %s\n", pos,
3060 debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
3066 static void arbfp_add_sRGB_correction(struct wined3d_shader_buffer *buffer, const char *fragcolor,
3067 const char *tmp1, const char *tmp2, const char *tmp3, const char *tmp4, BOOL condcode)
3069 /* Perform sRGB write correction. See GLX_EXT_framebuffer_sRGB */
3073 /* Sigh. MOVC CC doesn't work, so use one of the temps as dummy dest */
3074 shader_addline(buffer, "SUBC %s, %s.x, srgb_consts1.y;\n", tmp1, fragcolor);
3075 /* Calculate the > 0.0031308 case */
3076 shader_addline(buffer, "POW %s.x (GE), %s.x, srgb_consts1.z;\n", fragcolor, fragcolor);
3077 shader_addline(buffer, "POW %s.y (GE), %s.y, srgb_consts1.z;\n", fragcolor, fragcolor);
3078 shader_addline(buffer, "POW %s.z (GE), %s.z, srgb_consts1.z;\n", fragcolor, fragcolor);
3079 shader_addline(buffer, "MUL %s.xyz (GE), %s, srgb_consts1.w;\n", fragcolor, fragcolor);
3080 shader_addline(buffer, "SUB %s.xyz (GE), %s, srgb_consts2.x;\n", fragcolor, fragcolor);
3081 /* Calculate the < case */
3082 shader_addline(buffer, "MUL %s.xyz (LT), srgb_consts1.x, %s;\n", fragcolor, fragcolor);
3086 /* Calculate the > 0.0031308 case */
3087 shader_addline(buffer, "POW %s.x, %s.x, srgb_consts1.z;\n", tmp1, fragcolor);
3088 shader_addline(buffer, "POW %s.y, %s.y, srgb_consts1.z;\n", tmp1, fragcolor);
3089 shader_addline(buffer, "POW %s.z, %s.z, srgb_consts1.z;\n", tmp1, fragcolor);
3090 shader_addline(buffer, "MUL %s, %s, srgb_consts1.w;\n", tmp1, tmp1);
3091 shader_addline(buffer, "SUB %s, %s, srgb_consts2.x;\n", tmp1, tmp1);
3092 /* Calculate the < case */
3093 shader_addline(buffer, "MUL %s, srgb_consts1.x, %s;\n", tmp2, fragcolor);
3094 /* Get 1.0 / 0.0 masks for > 0.0031308 and < 0.0031308 */
3095 shader_addline(buffer, "SLT %s, srgb_consts1.y, %s;\n", tmp3, fragcolor);
3096 shader_addline(buffer, "SGE %s, srgb_consts1.y, %s;\n", tmp4, fragcolor);
3097 /* Store the components > 0.0031308 in the destination */
3098 shader_addline(buffer, "MUL %s.xyz, %s, %s;\n", fragcolor, tmp1, tmp3);
3099 /* Add the components that are < 0.0031308 */
3100 shader_addline(buffer, "MAD %s.xyz, %s, %s, %s;\n", fragcolor, tmp2, tmp4, fragcolor);
3101 /* Move everything into result.color at once. Nvidia hardware cannot handle partial
3102 * result.color writes(.rgb first, then .a), or handle overwriting already written
3103 * components. The assembler uses a temporary register in this case, which is usually
3104 * not allocated from one of our registers that were used earlier.
3107 shader_addline(buffer, "MOV result.color, %s;\n", fragcolor);
3108 /* [0.0;1.0] clamping. Not needed, this is done implicitly */
3111 static const DWORD *find_loop_control_values(IWineD3DBaseShaderImpl *This, DWORD idx)
3113 const local_constant *constant;
3115 LIST_FOR_EACH_ENTRY(constant, &This->baseShader.constantsI, local_constant, entry)
3117 if (constant->idx == idx)
3119 return constant->value;
3125 static void init_ps_input(const IWineD3DPixelShaderImpl *This, const struct arb_ps_compile_args *args,
3126 struct shader_arb_ctx_priv *priv)
3128 const char *texcoords[8] =
3130 "fragment.texcoord[0]", "fragment.texcoord[1]", "fragment.texcoord[2]", "fragment.texcoord[3]",
3131 "fragment.texcoord[4]", "fragment.texcoord[5]", "fragment.texcoord[6]", "fragment.texcoord[7]"
3134 const struct wined3d_shader_signature_element *sig = This->input_signature;
3135 const char *semantic_name;
3138 switch(args->super.vp_mode)
3140 case pretransformed:
3142 /* The pixelshader has to collect the varyings on its own. In any case properly load
3143 * color0 and color1. In the case of pretransformed vertices also load texcoords. Set
3144 * other attribs to 0.0.
3146 * For fixedfunction this behavior is correct, according to the tests. For pretransformed
3147 * we'd either need a replacement shader that can load other attribs like BINORMAL, or
3148 * load the texcoord attrib pointers to match the pixel shader signature
3150 for(i = 0; i < MAX_REG_INPUT; i++)
3152 semantic_name = sig[i].semantic_name;
3153 semantic_idx = sig[i].semantic_idx;
3154 if(semantic_name == NULL) continue;
3156 if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_COLOR))
3158 if(semantic_idx == 0) priv->ps_input[i] = "fragment.color.primary";
3159 else if(semantic_idx == 1) priv->ps_input[i] = "fragment.color.secondary";
3160 else priv->ps_input[i] = "0.0";
3162 else if(args->super.vp_mode == fixedfunction)
3164 priv->ps_input[i] = "0.0";
3166 else if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_TEXCOORD))
3168 if(semantic_idx < 8) priv->ps_input[i] = texcoords[semantic_idx];
3169 else priv->ps_input[i] = "0.0";
3171 else if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_FOG))
3173 if(semantic_idx == 0) priv->ps_input[i] = "fragment.fogcoord";
3174 else priv->ps_input[i] = "0.0";
3178 priv->ps_input[i] = "0.0";
3181 TRACE("v%u, semantic %s%u is %s\n", i, semantic_name, semantic_idx, priv->ps_input[i]);
3186 /* That one is easy. The vertex shaders provide v0-v7 in fragment.texcoord and v8 and v9 in
3189 for(i = 0; i < 8; i++)
3191 priv->ps_input[i] = texcoords[i];
3193 priv->ps_input[8] = "fragment.color.primary";
3194 priv->ps_input[9] = "fragment.color.secondary";
3199 /* GL locking is done by the caller */
3200 static GLuint shader_arb_generate_pshader(IWineD3DPixelShaderImpl *This, struct wined3d_shader_buffer *buffer,
3201 const struct arb_ps_compile_args *args, struct arb_ps_compiled_shader *compiled)
3203 const shader_reg_maps* reg_maps = &This->baseShader.reg_maps;
3204 CONST DWORD *function = This->baseShader.function;
3205 const WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *)This->baseShader.device)->adapter->gl_info;
3206 const local_constant *lconst;
3209 DWORD *lconst_map = local_const_mapping((IWineD3DBaseShaderImpl *) This), next_local, cur;
3210 struct shader_arb_ctx_priv priv_ctx;
3211 BOOL dcl_tmp = args->super.srgb_correction, dcl_td = FALSE;
3212 BOOL want_nv_prog = FALSE;
3213 struct arb_pshader_private *shader_priv = This->backend_priv;
3216 unsigned int i, found = 0;
3218 for(i = 0; i < This->baseShader.limits.temporary; i++) {
3220 /* Don't overwrite the color source */
3221 if(This->color0_mov && i == This->color0_reg) continue;
3222 else if(reg_maps->shader_version.major < 2 && i == 0) continue;
3224 if(reg_maps->temporary[i]) {
3225 sprintf(srgbtmp[found], "R%u", i);
3227 if(found == 4) break;
3232 case 4: dcl_tmp = FALSE; break;
3234 sprintf(srgbtmp[0], "TA");
3235 sprintf(srgbtmp[1], "TB");
3236 sprintf(srgbtmp[2], "TC");
3237 sprintf(srgbtmp[3], "TD");
3241 sprintf(srgbtmp[1], "TA");
3242 sprintf(srgbtmp[2], "TB");
3243 sprintf(srgbtmp[3], "TC");
3246 sprintf(srgbtmp[2], "TA");
3247 sprintf(srgbtmp[3], "TB");
3250 sprintf(srgbtmp[3], "TA");
3254 /* Create the hw ARB shader */
3255 memset(&priv_ctx, 0, sizeof(priv_ctx));
3256 priv_ctx.cur_ps_args = args;
3257 priv_ctx.compiled_fprog = compiled;
3258 priv_ctx.cur_np2fixup_info = &compiled->np2fixup_info;
3259 init_ps_input(This, args, &priv_ctx);
3260 list_init(&priv_ctx.control_frames);
3262 /* Avoid enabling NV_fragment_program* if we do not need it.
3264 * Enabling GL_NV_fragment_program_option causes the driver to occupy a temporary register,
3265 * and it slows down the shader execution noticeably(about 5%). Usually our instruction emulation
3266 * is faster than what we gain from using higher native instructions. There are some things though
3267 * that cannot be emulated. In that case enable the extensions.
3268 * If the extension is enabled, instruction handlers that support both ways will use it.
3270 * Testing shows no performance difference between OPTION NV_fragment_program2 and NV_fragment_program.
3271 * So enable the best we can get.
3273 if(reg_maps->usesdsx || reg_maps->usesdsy || reg_maps->loop_depth > 0 || reg_maps->usestexldd ||
3274 reg_maps->usestexldl || reg_maps->usesfacing || reg_maps->usesifc || reg_maps->usescall)
3276 want_nv_prog = TRUE;
3279 shader_addline(buffer, "!!ARBfp1.0\n");
3280 if(want_nv_prog && GL_SUPPORT(NV_FRAGMENT_PROGRAM2)) {
3281 shader_addline(buffer, "OPTION NV_fragment_program2;\n");
3282 priv_ctx.target_version = NV3;
3283 } else if(want_nv_prog && GL_SUPPORT(NV_FRAGMENT_PROGRAM_OPTION)) {
3284 shader_addline(buffer, "OPTION NV_fragment_program;\n");
3285 priv_ctx.target_version = NV2;
3289 /* This is an error - either we're advertising the wrong shader version, or aren't enforcing some
3292 ERR("The shader requires instructions that are not available in plain GL_ARB_fragment_program\n");
3295 priv_ctx.target_version = ARB;
3298 if(This->baseShader.reg_maps.highest_render_target > 0)
3300 shader_addline(buffer, "OPTION ARB_draw_buffers;\n");
3303 if (reg_maps->shader_version.major < 3)
3305 switch(args->super.fog) {
3309 shader_addline(buffer, "OPTION ARB_fog_linear;\n");
3312 shader_addline(buffer, "OPTION ARB_fog_exp;\n");
3315 shader_addline(buffer, "OPTION ARB_fog_exp2;\n");
3320 /* For now always declare the temps. At least the Nvidia assembler optimizes completely
3321 * unused temps away(but occupies them for the whole shader if they're used once). Always
3322 * declaring them avoids tricky bookkeeping work
3324 shader_addline(buffer, "TEMP TA;\n"); /* Used for modifiers */
3325 shader_addline(buffer, "TEMP TB;\n"); /* Used for modifiers */
3326 shader_addline(buffer, "TEMP TC;\n"); /* Used for modifiers */
3327 if(dcl_td) shader_addline(buffer, "TEMP TD;\n"); /* Used for sRGB writing */
3328 shader_addline(buffer, "PARAM coefdiv = { 0.5, 0.25, 0.125, 0.0625 };\n");
3329 shader_addline(buffer, "PARAM coefmul = { 2, 4, 8, 16 };\n");
3330 shader_addline(buffer, "PARAM one = { 1.0, 1.0, 1.0, 1.0 };\n");
3332 if (reg_maps->shader_version.major < 2)
3334 strcpy(fragcolor, "R0");
3336 if(args->super.srgb_correction) {
3337 if(This->color0_mov) {
3338 sprintf(fragcolor, "R%u", This->color0_reg);
3340 shader_addline(buffer, "TEMP TMP_COLOR;\n");
3341 strcpy(fragcolor, "TMP_COLOR");
3344 strcpy(fragcolor, "result.color");
3348 if(args->super.srgb_correction) {
3349 shader_addline(buffer, "PARAM srgb_consts1 = {%f, %f, %f, %f};\n",
3350 srgb_mul_low, srgb_cmp, srgb_pow, srgb_mul_high);
3351 shader_addline(buffer, "PARAM srgb_consts2 = {%f, %f, %f, %f};\n",
3352 srgb_sub_high, 0.0, 0.0, 0.0);
3355 /* Base Declarations */
3356 next_local = shader_generate_arb_declarations( (IWineD3DBaseShader*) This, reg_maps, buffer, &GLINFO_LOCATION,
3357 lconst_map, NULL, &priv_ctx);
3359 for(i = 0; i < (sizeof(reg_maps->bumpmat) / sizeof(reg_maps->bumpmat[0])); i++) {
3360 if(!reg_maps->bumpmat[i]) continue;
3362 cur = compiled->numbumpenvmatconsts;
3363 compiled->bumpenvmatconst[cur].const_num = WINED3D_CONST_NUM_UNUSED;
3364 compiled->bumpenvmatconst[cur].texunit = i;
3365 compiled->luminanceconst[cur].const_num = WINED3D_CONST_NUM_UNUSED;
3366 compiled->luminanceconst[cur].texunit = i;
3368 /* We can fit the constants into the constant limit for sure because texbem, texbeml, bem and beml are only supported
3369 * in 1.x shaders, and GL_ARB_fragment_program has a constant limit of 24 constants. So in the worst case we're loading
3370 * 8 shader constants, 8 bump matrices and 8 luminance parameters and are perfectly fine. (No NP2 fixup on bumpmapped
3371 * textures due to conditional NP2 restrictions)
3373 * Use local constants to load the bump env parameters, not program.env. This avoids collisions with d3d constants of
3374 * shaders in newer shader models. Since the bump env parameters have to share their space with NP2 fixup constants,
3375 * their location is shader dependent anyway and they cannot be loaded globally.
3377 compiled->bumpenvmatconst[cur].const_num = next_local++;
3378 shader_addline(buffer, "PARAM bumpenvmat%d = program.local[%d];\n",
3379 i, compiled->bumpenvmatconst[cur].const_num);
3380 compiled->numbumpenvmatconsts = cur + 1;
3382 if(!reg_maps->luminanceparams[i]) continue;
3384 compiled->luminanceconst[cur].const_num = next_local++;
3385 shader_addline(buffer, "PARAM luminance%d = program.local[%d];\n",
3386 i, compiled->luminanceconst[cur].const_num);
3389 for(i = 0; i < MAX_CONST_I; i++)
3391 compiled->int_consts[i] = WINED3D_CONST_NUM_UNUSED;
3392 if (reg_maps->integer_constants & (1 << i) && priv_ctx.target_version >= NV2)
3394 const DWORD *control_values = find_loop_control_values((IWineD3DBaseShaderImpl *) This, i);
3398 shader_addline(buffer, "PARAM I%u = {%u, %u, %u, -1};\n", i,
3399 control_values[0], control_values[1], control_values[2]);
3403 compiled->int_consts[i] = next_local;
3404 compiled->num_int_consts++;
3405 shader_addline(buffer, "PARAM I%u = program.local[%u];\n", i, next_local++);
3410 if(reg_maps->vpos || reg_maps->usesdsy)
3412 compiled->ycorrection = next_local;
3413 shader_addline(buffer, "PARAM ycorrection = program.local[%u];\n", next_local++);
3417 shader_addline(buffer, "TEMP vpos;\n");
3418 /* ycorrection.x: Backbuffer height(onscreen) or 0(offscreen).
3419 * ycorrection.y: -1.0(onscreen), 1.0(offscreen)
3420 * ycorrection.z: 1.0
3421 * ycorrection.w: 0.0
3423 shader_addline(buffer, "MAD vpos, fragment.position, ycorrection.zyww, ycorrection.wxww;\n");
3424 shader_addline(buffer, "FLR vpos.xy, vpos;\n");
3429 compiled->ycorrection = WINED3D_CONST_NUM_UNUSED;
3432 /* Load constants to fixup NP2 texcoords if there are still free constants left:
3433 * Constants (texture dimensions) for the NP2 fixup are loaded as local program parameters. This will consume
3434 * at most 8 (MAX_FRAGMENT_SAMPLERS / 2) parameters, which is highly unlikely, since the application had to
3435 * use 16 NP2 textures at the same time. In case that we run out of constants the fixup is simply not
3436 * applied / activated. This will probably result in wrong rendering of the texture, but will save us from
3437 * shader compilation errors and the subsequent errors when drawing with this shader. */
3438 if (priv_ctx.cur_ps_args->super.np2_fixup) {
3440 struct arb_ps_np2fixup_info* const fixup = priv_ctx.cur_np2fixup_info;
3441 const WORD map = priv_ctx.cur_ps_args->super.np2_fixup;
3442 const UINT max_lconsts = gl_info->ps_arb_max_local_constants;
3444 fixup->offset = next_local;
3445 fixup->super.active = 0;
3448 for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i) {
3449 if (!(map & (1 << i))) continue;
3451 if (fixup->offset + (cur >> 1) < max_lconsts) {
3452 fixup->super.active |= (1 << i);
3453 fixup->super.idx[i] = cur++;
3455 FIXME("No free constant found to load NP2 fixup data into shader. "
3456 "Sampling from this texture will probably look wrong.\n");
3461 fixup->super.num_consts = (cur + 1) >> 1;
3462 if (fixup->super.num_consts) {
3463 shader_addline(buffer, "PARAM np2fixup[%u] = { program.env[%u..%u] };\n",
3464 fixup->super.num_consts, fixup->offset, fixup->super.num_consts + fixup->offset - 1);
3467 next_local += fixup->super.num_consts;
3470 if(shader_priv->clipplane_emulation)
3472 shader_addline(buffer, "KIL fragment.texcoord[%u];\n", shader_priv->clipplane_emulation - 1);
3475 /* Base Shader Body */
3476 shader_generate_main((IWineD3DBaseShader *)This, buffer, reg_maps, function, &priv_ctx);
3478 if(args->super.srgb_correction) {
3479 arbfp_add_sRGB_correction(buffer, fragcolor, srgbtmp[0], srgbtmp[1], srgbtmp[2], srgbtmp[3],
3480 priv_ctx.target_version >= NV2);
3481 } else if(reg_maps->shader_version.major < 2) {
3482 shader_addline(buffer, "MOV result.color, %s;\n", fragcolor);
3484 shader_addline(buffer, "END\n");
3486 /* TODO: change to resource.glObjectHandle or something like that */
3487 GL_EXTCALL(glGenProgramsARB(1, &retval));
3489 TRACE("Creating a hw pixel shader, prg=%d\n", retval);
3490 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, retval));
3492 TRACE("Created hw pixel shader, prg=%d\n", retval);
3493 /* Create the program and check for errors */
3494 GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
3495 buffer->bsize, buffer->buffer));
3497 if (glGetError() == GL_INVALID_OPERATION) {
3499 glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos);
3500 FIXME("HW PixelShader Error at position %d: %s\n",
3501 errPos, debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
3505 /* Load immediate constants */
3507 LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
3508 const float *value = (const float *)lconst->value;
3509 GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, lconst_map[lconst->idx], value));
3510 checkGLcall("glProgramLocalParameter4fvARB");
3512 HeapFree(GetProcessHeap(), 0, lconst_map);
3518 static int compare_sig(const struct wined3d_shader_signature_element *sig1, const struct wined3d_shader_signature_element *sig2)
3523 for(i = 0; i < MAX_REG_INPUT; i++)
3525 if(sig1[i].semantic_name == NULL || sig2[i].semantic_name == NULL)
3527 /* Compare pointers, not contents. One string is NULL(element does not exist), the other one is not NULL */
3528 if(sig1[i].semantic_name != sig2[i].semantic_name) return sig1[i].semantic_name < sig2[i].semantic_name ? -1 : 1;
3532 ret = strcmp(sig1[i].semantic_name, sig2[i].semantic_name);
3533 if(ret != 0) return ret;
3534 if(sig1[i].semantic_idx != sig2[i].semantic_idx) return sig1[i].semantic_idx < sig2[i].semantic_idx ? -1 : 1;
3535 if(sig1[i].sysval_semantic != sig2[i].sysval_semantic) return sig1[i].sysval_semantic < sig2[i].sysval_semantic ? -1 : 1;
3536 if(sig1[i].component_type != sig2[i].component_type) return sig1[i].sysval_semantic < sig2[i].component_type ? -1 : 1;
3537 if(sig1[i].register_idx != sig2[i].register_idx) return sig1[i].register_idx < sig2[i].register_idx ? -1 : 1;
3538 if(sig1[i].mask != sig2->mask) return sig1[i].mask < sig2[i].mask ? -1 : 1;
3543 static struct wined3d_shader_signature_element *clone_sig(const struct wined3d_shader_signature_element *sig)
3545 struct wined3d_shader_signature_element *new;
3549 new = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*new) * MAX_REG_INPUT);
3550 for(i = 0; i < MAX_REG_INPUT; i++)
3552 if(sig[i].semantic_name == NULL)
3558 /* Clone the semantic string */
3559 name = HeapAlloc(GetProcessHeap(), 0, strlen(sig[i].semantic_name) + 1);
3560 strcpy(name, sig[i].semantic_name);
3561 new[i].semantic_name = name;
3566 static DWORD find_input_signature(struct shader_arb_priv *priv, const struct wined3d_shader_signature_element *sig)
3568 struct wine_rb_entry *entry = wine_rb_get(&priv->signature_tree, sig);
3569 struct ps_signature *found_sig;
3573 found_sig = WINE_RB_ENTRY_VALUE(entry, struct ps_signature, entry);
3574 TRACE("Found existing signature %u\n", found_sig->idx);
3575 return found_sig->idx;
3577 found_sig = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*sig));
3578 found_sig->sig = clone_sig(sig);
3579 found_sig->idx = priv->ps_sig_number++;
3580 TRACE("New signature stored and assigned number %u\n", found_sig->idx);
3581 if(wine_rb_put(&priv->signature_tree, sig, &found_sig->entry) == -1)
3583 ERR("Failed to insert program entry.\n");
3585 return found_sig->idx;
3588 static void init_output_registers(IWineD3DVertexShaderImpl *shader, DWORD sig_num, struct shader_arb_ctx_priv *priv_ctx,
3589 struct arb_vs_compiled_shader *compiled)
3592 static const char *texcoords[8] =
3594 "result.texcoord[0]", "result.texcoord[1]", "result.texcoord[2]", "result.texcoord[3]",
3595 "result.texcoord[4]", "result.texcoord[5]", "result.texcoord[6]", "result.texcoord[7]"
3597 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) shader->baseShader.device;
3598 const struct wined3d_shader_signature_element *sig;
3599 const char *semantic_name;
3600 DWORD semantic_idx, reg_idx;
3602 /* Write generic input varyings 0 to 7 to result.texcoord[], varying 8 to result.color.primary
3603 * and varying 9 to result.color.secondary
3605 const char *decl_idx_to_string[MAX_REG_INPUT] =
3607 texcoords[0], texcoords[1], texcoords[2], texcoords[3],
3608 texcoords[4], texcoords[5], texcoords[6], texcoords[7],
3609 "result.color.primary", "result.color.secondary"
3614 TRACE("Pixel shader uses builtin varyings\n");
3615 /* Map builtins to builtins */
3616 for(i = 0; i < 8; i++)
3618 priv_ctx->texcrd_output[i] = texcoords[i];
3620 priv_ctx->color_output[0] = "result.color.primary";
3621 priv_ctx->color_output[1] = "result.color.secondary";
3622 priv_ctx->fog_output = "result.fogcoord";
3624 /* Map declared regs to builtins. Use "TA" to /dev/null unread output */
3625 for(i = 0; i < (sizeof(shader->output_signature) / sizeof(*shader->output_signature)); i++)
3627 semantic_name = shader->output_signature[i].semantic_name;
3628 if(semantic_name == NULL) continue;
3630 if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_POSITION))
3632 TRACE("o%u is TMP_OUT\n", i);
3633 if(shader->output_signature[i].semantic_idx == 0) priv_ctx->vs_output[i] = "TMP_OUT";
3634 else priv_ctx->vs_output[i] = "TA";
3636 else if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_PSIZE))
3638 TRACE("o%u is result.pointsize\n", i);
3639 if(shader->output_signature[i].semantic_idx == 0) priv_ctx->vs_output[i] = "result.pointsize";
3640 else priv_ctx->vs_output[i] = "TA";
3642 else if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_COLOR))
3644 TRACE("o%u is result.color.?, idx %u\n", i, shader->output_signature[i].semantic_idx);
3645 if(shader->output_signature[i].semantic_idx == 0) priv_ctx->vs_output[i] = "result.color.primary";
3646 else if(shader->output_signature[i].semantic_idx == 1) priv_ctx->vs_output[i] = "result.color.secondary";
3647 else priv_ctx->vs_output[i] = "TA";
3649 else if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_TEXCOORD))
3651 TRACE("o%u is %s\n", i, texcoords[shader->output_signature[i].semantic_idx]);
3652 if(shader->output_signature[i].semantic_idx >= 8) priv_ctx->vs_output[i] = "TA";
3653 else priv_ctx->vs_output[i] = texcoords[shader->output_signature[i].semantic_idx];
3655 else if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_FOG))
3657 TRACE("o%u is result.fogcoord\n", i);
3658 if(shader->output_signature[i].semantic_idx > 0) priv_ctx->vs_output[i] = "TA";
3659 else priv_ctx->vs_output[i] = "result.fogcoord";
3663 priv_ctx->vs_output[i] = "TA";
3669 /* Instead of searching for the signature in the signature list, read the one from the current pixel shader.
3670 * Its maybe not the shader where the signature came from, but it is the same signature and faster to find
3672 sig = ((IWineD3DPixelShaderImpl *)device->stateBlock->pixelShader)->input_signature;
3673 TRACE("Pixel shader uses declared varyings\n");
3675 /* Map builtin to declared. /dev/null the results by default to the TA temp reg */
3676 for(i = 0; i < 8; i++)
3678 priv_ctx->texcrd_output[i] = "TA";
3680 priv_ctx->color_output[0] = "TA";
3681 priv_ctx->color_output[1] = "TA";
3682 priv_ctx->fog_output = "TA";
3684 for(i = 0; i < MAX_REG_INPUT; i++)
3686 semantic_name = sig[i].semantic_name;
3687 semantic_idx = sig[i].semantic_idx;
3688 reg_idx = sig[i].register_idx;
3689 if(semantic_name == NULL) continue;
3691 /* If a declared input register is not written by builtin arguments, don't write to it.
3692 * GL_NV_vertex_program makes sure the input defaults to 0.0, which is correct with D3D
3694 * Don't care about POSITION and PSIZE here - this is a builtin vertex shader, position goes
3695 * to TMP_OUT in any case
3697 if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_TEXCOORD))
3699 if(semantic_idx < 8) priv_ctx->texcrd_output[semantic_idx] = decl_idx_to_string[reg_idx];
3701 else if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_COLOR))
3703 if(semantic_idx < 2) priv_ctx->color_output[semantic_idx] = decl_idx_to_string[reg_idx];
3705 else if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_FOG))
3707 if(semantic_idx == 0) priv_ctx->fog_output = decl_idx_to_string[reg_idx];
3714 if(strcmp(decl_idx_to_string[reg_idx], "result.color.primary") == 0 ||
3715 strcmp(decl_idx_to_string[reg_idx], "result.color.secondary") == 0)
3717 compiled->need_color_unclamp = TRUE;
3721 /* Map declared to declared */
3722 for(i = 0; i < (sizeof(shader->output_signature) / sizeof(*shader->output_signature)); i++)
3724 /* Write unread output to TA to throw them away */
3725 priv_ctx->vs_output[i] = "TA";
3726 semantic_name = shader->output_signature[i].semantic_name;
3727 if(semantic_name == NULL)
3732 if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_POSITION) &&
3733 shader->output_signature[i].semantic_idx == 0)
3735 priv_ctx->vs_output[i] = "TMP_OUT";
3738 else if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_PSIZE) &&
3739 shader->output_signature[i].semantic_idx == 0)
3741 priv_ctx->vs_output[i] = "result.pointsize";
3745 for(j = 0; j < MAX_REG_INPUT; j++)
3747 if(sig[j].semantic_name == NULL)
3752 if(strcmp(sig[j].semantic_name, semantic_name) == 0 &&
3753 sig[j].semantic_idx == shader->output_signature[i].semantic_idx)
3755 priv_ctx->vs_output[i] = decl_idx_to_string[sig[j].register_idx];
3757 if(strcmp(priv_ctx->vs_output[i], "result.color.primary") == 0 ||
3758 strcmp(priv_ctx->vs_output[i], "result.color.secondary") == 0)
3760 compiled->need_color_unclamp = TRUE;
3767 /* GL locking is done by the caller */
3768 static GLuint shader_arb_generate_vshader(IWineD3DVertexShaderImpl *This, struct wined3d_shader_buffer *buffer,
3769 const struct arb_vs_compile_args *args, struct arb_vs_compiled_shader *compiled)
3771 const shader_reg_maps *reg_maps = &This->baseShader.reg_maps;
3772 CONST DWORD *function = This->baseShader.function;
3773 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *)This->baseShader.device;
3774 const WineD3D_GL_Info *gl_info = &device->adapter->gl_info;
3775 const local_constant *lconst;
3777 DWORD next_local, *lconst_map = local_const_mapping((IWineD3DBaseShaderImpl *) This);
3778 struct shader_arb_ctx_priv priv_ctx;
3781 memset(&priv_ctx, 0, sizeof(priv_ctx));
3782 priv_ctx.cur_vs_args = args;
3783 list_init(&priv_ctx.control_frames);
3784 init_output_registers(This, args->ps_signature, &priv_ctx, compiled);
3786 /* Create the hw ARB shader */
3787 shader_addline(buffer, "!!ARBvp1.0\n");
3789 /* Always enable the NV extension if available. Unlike fragment shaders, there is no
3790 * mesurable performance penalty, and we can always make use of it for clipplanes.
3792 if(GL_SUPPORT(NV_VERTEX_PROGRAM3)) {
3793 shader_addline(buffer, "OPTION NV_vertex_program3;\n");
3794 priv_ctx.target_version = NV3;
3795 shader_addline(buffer, "ADDRESS aL;\n");
3796 } else if(GL_SUPPORT(NV_VERTEX_PROGRAM2_OPTION)) {
3797 shader_addline(buffer, "OPTION NV_vertex_program2;\n");
3798 priv_ctx.target_version = NV2;
3799 shader_addline(buffer, "ADDRESS aL;\n");
3801 priv_ctx.target_version = ARB;
3804 shader_addline(buffer, "TEMP TMP_OUT;\n");
3805 if(need_helper_const(gl_info)) {
3806 shader_addline(buffer, "PARAM helper_const = { 2.0, -1.0, %d.0, 0.0 };\n", This->rel_offset);
3808 if(need_mova_const((IWineD3DBaseShader *) This, gl_info)) {
3809 shader_addline(buffer, "PARAM mova_const = { 0.5, 0.0, 2.0, 1.0 };\n");
3810 shader_addline(buffer, "TEMP A0_SHADOW;\n");
3813 shader_addline(buffer, "TEMP TA;\n");
3815 /* Base Declarations */
3816 next_local = shader_generate_arb_declarations( (IWineD3DBaseShader*) This, reg_maps, buffer, &GLINFO_LOCATION,
3817 lconst_map, &priv_ctx.vs_clipplanes, &priv_ctx);
3819 for(i = 0; i < MAX_CONST_I; i++)
3821 compiled->int_consts[i] = WINED3D_CONST_NUM_UNUSED;
3822 if(reg_maps->integer_constants & (1 << i) && priv_ctx.target_version >= NV2)
3824 const DWORD *control_values = find_loop_control_values((IWineD3DBaseShaderImpl *) This, i);
3828 shader_addline(buffer, "PARAM I%u = {%u, %u, %u, -1};\n", i,
3829 control_values[0], control_values[1], control_values[2]);
3833 compiled->int_consts[i] = next_local;
3834 compiled->num_int_consts++;
3835 shader_addline(buffer, "PARAM I%u = program.local[%u];\n", i, next_local++);
3840 /* We need a constant to fixup the final position */
3841 shader_addline(buffer, "PARAM posFixup = program.local[%u];\n", next_local);
3842 compiled->pos_fixup = next_local++;
3844 /* Initialize output parameters. GL_ARB_vertex_program does not require special initialization values
3845 * for output parameters. D3D in theory does not do that either, but some applications depend on a
3846 * proper initialization of the secondary color, and programs using the fixed function pipeline without
3847 * a replacement shader depend on the texcoord.w being set properly.
3849 * GL_NV_vertex_program defines that all output values are initialized to {0.0, 0.0, 0.0, 1.0}. This
3850 * assertion is in effect even when using GL_ARB_vertex_program without any NV specific additions. So
3851 * skip this if NV_vertex_program is supported. Otherwise, initialize the secondary color. For the tex-
3852 * coords, we have a flag in the opengl caps. Many cards do not require the texcoord being set, and
3853 * this can eat a number of instructions, so skip it unless this cap is set as well
3855 if(!GL_SUPPORT(NV_VERTEX_PROGRAM)) {
3856 shader_addline(buffer, "MOV result.color.secondary, -helper_const.wwwy;\n");
3858 if ((GLINFO_LOCATION).quirks & WINED3D_QUIRK_SET_TEXCOORD_W && !device->frag_pipe->ffp_proj_control)
3861 for(i = 0; i < min(8, MAX_REG_TEXCRD); i++) {
3862 if(This->baseShader.reg_maps.texcoord_mask[i] != 0 &&
3863 This->baseShader.reg_maps.texcoord_mask[i] != WINED3DSP_WRITEMASK_ALL) {
3864 shader_addline(buffer, "MOV result.texcoord[%u].w, -helper_const.y;\n", i);
3870 /* The shader starts with the main function */
3871 priv_ctx.in_main_func = TRUE;
3872 /* Base Shader Body */
3873 shader_generate_main((IWineD3DBaseShader *)This, buffer, reg_maps, function, &priv_ctx);
3875 if(!priv_ctx.footer_written) vshader_add_footer(This, buffer, args, &priv_ctx);
3877 shader_addline(buffer, "END\n");
3879 /* TODO: change to resource.glObjectHandle or something like that */
3880 GL_EXTCALL(glGenProgramsARB(1, &ret));
3882 TRACE("Creating a hw vertex shader, prg=%d\n", ret);
3883 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, ret));
3885 TRACE("Created hw vertex shader, prg=%d\n", ret);
3886 /* Create the program and check for errors */
3887 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
3888 buffer->bsize, buffer->buffer));
3890 if (glGetError() == GL_INVALID_OPERATION) {
3892 glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos);
3893 FIXME("HW VertexShader Error at position %d: %s\n",
3894 errPos, debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
3897 /* Load immediate constants */
3899 LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
3900 const float *value = (const float *)lconst->value;
3901 GL_EXTCALL(glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, lconst_map[lconst->idx], value));
3905 HeapFree(GetProcessHeap(), 0, lconst_map);
3910 static void find_clip_texcoord(IWineD3DPixelShaderImpl *ps)
3912 struct arb_pshader_private *shader_priv = ps->backend_priv;
3914 const WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *)ps->baseShader.device)->adapter->gl_info;
3916 /* See if we can use fragment.texcoord[7] for clipplane emulation
3918 * Don't do this if it is not supported, or fragment.texcoord[7] is used
3920 if(ps->baseShader.reg_maps.shader_version.major < 3)
3922 for(i = GL_LIMITS(texture_stages); i > 0; i--)
3924 if(!ps->baseShader.reg_maps.texcoord[i - 1])
3926 shader_priv->clipplane_emulation = i;
3930 WARN("Did not find a free clip reg(2.0)\n");
3934 for(i = GL_LIMITS(texture_stages); i > 0; i--)
3936 if(!(ps->baseShader.reg_maps.input_registers & (1 << (i - 1))))
3938 shader_priv->clipplane_emulation = i;
3942 WARN("Did not find a free clip reg(3.0)\n");
3946 /* GL locking is done by the caller */
3947 static struct arb_ps_compiled_shader *find_arb_pshader(IWineD3DPixelShaderImpl *shader, const struct arb_ps_compile_args *args)
3951 struct arb_ps_compiled_shader *new_array;
3952 struct wined3d_shader_buffer buffer;
3953 struct arb_pshader_private *shader_data;
3956 if(!shader->backend_priv) {
3957 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) shader->baseShader.device;
3958 struct shader_arb_priv *priv = device->shader_priv;
3960 shader->backend_priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
3961 shader_data = shader->backend_priv;
3962 shader_data->clamp_consts = shader->baseShader.reg_maps.shader_version.major == 1;
3964 if(shader->baseShader.reg_maps.shader_version.major < 3) shader_data->input_signature_idx = ~0;
3965 else shader_data->input_signature_idx = find_input_signature(priv, shader->input_signature);
3967 shader_data->has_signature_idx = TRUE;
3968 TRACE("Shader got assigned input signature index %u\n", shader_data->input_signature_idx);
3970 if(!device->vs_clipping) find_clip_texcoord(shader);
3972 shader_data = shader->backend_priv;
3974 /* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
3975 * so a linear search is more performant than a hashmap or a binary search
3976 * (cache coherency etc)
3978 for(i = 0; i < shader_data->num_gl_shaders; i++) {
3979 if(memcmp(&shader_data->gl_shaders[i].args, args, sizeof(*args)) == 0) {
3980 return &shader_data->gl_shaders[i];
3984 TRACE("No matching GL shader found, compiling a new shader\n");
3985 if(shader_data->shader_array_size == shader_data->num_gl_shaders) {
3986 if (shader_data->num_gl_shaders)
3988 new_size = shader_data->shader_array_size + max(1, shader_data->shader_array_size / 2);
3989 new_array = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, shader_data->gl_shaders,
3990 new_size * sizeof(*shader_data->gl_shaders));
3992 new_array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data->gl_shaders));
3997 ERR("Out of memory\n");
4000 shader_data->gl_shaders = new_array;
4001 shader_data->shader_array_size = new_size;
4004 shader_data->gl_shaders[shader_data->num_gl_shaders].args = *args;
4006 pixelshader_update_samplers(&shader->baseShader.reg_maps,
4007 ((IWineD3DDeviceImpl *)shader->baseShader.device)->stateBlock->textures);
4009 if (!shader_buffer_init(&buffer))
4011 ERR("Failed to initialize shader buffer.\n");
4015 ret = shader_arb_generate_pshader(shader, &buffer, args,
4016 &shader_data->gl_shaders[shader_data->num_gl_shaders]);
4017 shader_buffer_free(&buffer);
4018 shader_data->gl_shaders[shader_data->num_gl_shaders].prgId = ret;
4020 return &shader_data->gl_shaders[shader_data->num_gl_shaders++];
4023 static inline BOOL vs_args_equal(const struct arb_vs_compile_args *stored, const struct arb_vs_compile_args *new,
4024 const DWORD use_map, BOOL skip_int) {
4025 if((stored->super.swizzle_map & use_map) != new->super.swizzle_map) return FALSE;
4026 if(stored->super.fog_src != new->super.fog_src) return FALSE;
4027 if(stored->boolclip_compare != new->boolclip_compare) return FALSE;
4028 if(stored->ps_signature != new->ps_signature) return FALSE;
4029 if(stored->vertex_samplers_compare != new->vertex_samplers_compare) return FALSE;
4030 if(skip_int) return TRUE;
4032 return memcmp(stored->loop_ctrl, new->loop_ctrl, sizeof(stored->loop_ctrl)) == 0;
4035 static struct arb_vs_compiled_shader *find_arb_vshader(IWineD3DVertexShaderImpl *shader, const struct arb_vs_compile_args *args)
4039 struct arb_vs_compiled_shader *new_array;
4040 DWORD use_map = ((IWineD3DDeviceImpl *)shader->baseShader.device)->strided_streams.use_map;
4041 struct wined3d_shader_buffer buffer;
4042 struct arb_vshader_private *shader_data;
4044 const WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *)shader->baseShader.device)->adapter->gl_info;
4046 if(!shader->backend_priv) {
4047 shader->backend_priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
4049 shader_data = shader->backend_priv;
4051 /* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
4052 * so a linear search is more performant than a hashmap or a binary search
4053 * (cache coherency etc)
4055 for(i = 0; i < shader_data->num_gl_shaders; i++) {
4056 if(vs_args_equal(&shader_data->gl_shaders[i].args, args, use_map, GL_SUPPORT(NV_VERTEX_PROGRAM2_OPTION))) {
4057 return &shader_data->gl_shaders[i];
4061 TRACE("No matching GL shader found, compiling a new shader\n");
4063 if(shader_data->shader_array_size == shader_data->num_gl_shaders) {
4064 if (shader_data->num_gl_shaders)
4066 new_size = shader_data->shader_array_size + max(1, shader_data->shader_array_size / 2);
4067 new_array = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, shader_data->gl_shaders,
4068 new_size * sizeof(*shader_data->gl_shaders));
4070 new_array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data->gl_shaders));
4075 ERR("Out of memory\n");
4078 shader_data->gl_shaders = new_array;
4079 shader_data->shader_array_size = new_size;
4082 shader_data->gl_shaders[shader_data->num_gl_shaders].args = *args;
4084 if (!shader_buffer_init(&buffer))
4086 ERR("Failed to initialize shader buffer.\n");
4090 ret = shader_arb_generate_vshader(shader, &buffer, args,
4091 &shader_data->gl_shaders[shader_data->num_gl_shaders]);
4092 shader_buffer_free(&buffer);
4093 shader_data->gl_shaders[shader_data->num_gl_shaders].prgId = ret;
4095 return &shader_data->gl_shaders[shader_data->num_gl_shaders++];
4098 static inline void find_arb_ps_compile_args(IWineD3DPixelShaderImpl *shader, IWineD3DStateBlockImpl *stateblock,
4099 struct arb_ps_compile_args *args)
4103 const WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *)shader->baseShader.device)->adapter->gl_info;
4104 find_ps_compile_args(shader, stateblock, &args->super);
4106 /* This forces all local boolean constants to 1 to make them stateblock independent */
4107 args->bools = shader->baseShader.reg_maps.local_bool_consts;
4109 for(i = 0; i < MAX_CONST_B; i++)
4111 if(stateblock->pixelShaderConstantB[i]) args->bools |= ( 1 << i);
4114 /* Skip if unused or local, or supported natively */
4115 int_skip = ~shader->baseShader.reg_maps.integer_constants | shader->baseShader.reg_maps.local_int_consts;
4116 if(int_skip == 0xffff || GL_SUPPORT(NV_FRAGMENT_PROGRAM_OPTION))
4118 memset(&args->loop_ctrl, 0, sizeof(args->loop_ctrl));
4122 for(i = 0; i < MAX_CONST_I; i++)
4124 if(int_skip & (1 << i))
4126 args->loop_ctrl[i][0] = 0;
4127 args->loop_ctrl[i][1] = 0;
4128 args->loop_ctrl[i][2] = 0;
4132 args->loop_ctrl[i][0] = stateblock->pixelShaderConstantI[i * 4];
4133 args->loop_ctrl[i][1] = stateblock->pixelShaderConstantI[i * 4 + 1];
4134 args->loop_ctrl[i][2] = stateblock->pixelShaderConstantI[i * 4 + 2];
4139 static inline void find_arb_vs_compile_args(IWineD3DVertexShaderImpl *shader, IWineD3DStateBlockImpl *stateblock,
4140 struct arb_vs_compile_args *args)
4144 IWineD3DDeviceImpl *dev = (IWineD3DDeviceImpl *)shader->baseShader.device;
4145 const WineD3D_GL_Info *gl_info = &dev->adapter->gl_info;
4146 find_vs_compile_args(shader, stateblock, &args->super);
4148 args->boolclip_compare = 0;
4149 if(use_ps(stateblock))
4151 IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *) stateblock->pixelShader;
4152 struct arb_pshader_private *shader_priv = ps->backend_priv;
4153 args->ps_signature = shader_priv->input_signature_idx;
4155 args->boolclip.clip_control[0] = shader_priv->clipplane_emulation;
4159 args->ps_signature = ~0;
4160 if(!dev->vs_clipping)
4162 args->boolclip.clip_control[0] = ffp_clip_emul(stateblock) ? GL_LIMITS(texture_stages) : 0;
4164 /* Otherwise: Setting boolclip_compare set clip_control[0] to 0 */
4167 if(args->boolclip.clip_control[0])
4169 if(stateblock->renderState[WINED3DRS_CLIPPING])
4171 args->boolclip.clip_control[1] = stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
4173 /* clip_control[1] was set to 0 by setting boolclip_compare to 0 */
4176 /* This forces all local boolean constants to 1 to make them stateblock independent */
4177 args->boolclip.bools = shader->baseShader.reg_maps.local_bool_consts;
4178 /* TODO: Figure out if it would be better to store bool constants as bitmasks in the stateblock */
4179 for(i = 0; i < MAX_CONST_B; i++)
4181 if(stateblock->vertexShaderConstantB[i]) args->boolclip.bools |= ( 1 << i);
4184 args->vertex_samplers[0] = dev->texUnitMap[MAX_FRAGMENT_SAMPLERS + 0];
4185 args->vertex_samplers[1] = dev->texUnitMap[MAX_FRAGMENT_SAMPLERS + 1];
4186 args->vertex_samplers[2] = dev->texUnitMap[MAX_FRAGMENT_SAMPLERS + 2];
4187 args->vertex_samplers[3] = 0;
4189 /* Skip if unused or local */
4190 int_skip = ~shader->baseShader.reg_maps.integer_constants | shader->baseShader.reg_maps.local_int_consts;
4191 if(int_skip == 0xffff || GL_SUPPORT(NV_VERTEX_PROGRAM2_OPTION)) /* This is about flow control, not clipping */
4193 memset(&args->loop_ctrl, 0, sizeof(args->loop_ctrl));
4197 for(i = 0; i < MAX_CONST_I; i++)
4199 if(int_skip & (1 << i))
4201 args->loop_ctrl[i][0] = 0;
4202 args->loop_ctrl[i][1] = 0;
4203 args->loop_ctrl[i][2] = 0;
4207 args->loop_ctrl[i][0] = stateblock->vertexShaderConstantI[i * 4];
4208 args->loop_ctrl[i][1] = stateblock->vertexShaderConstantI[i * 4 + 1];
4209 args->loop_ctrl[i][2] = stateblock->vertexShaderConstantI[i * 4 + 2];
4214 /* GL locking is done by the caller */
4215 static void shader_arb_select(IWineD3DDevice *iface, BOOL usePS, BOOL useVS) {
4216 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4217 struct shader_arb_priv *priv = This->shader_priv;
4218 const WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
4221 /* Deal with pixel shaders first so the vertex shader arg function has the input signature ready */
4223 struct arb_ps_compile_args compile_args;
4224 struct arb_ps_compiled_shader *compiled;
4225 IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *) This->stateBlock->pixelShader;
4227 TRACE("Using pixel shader %p\n", This->stateBlock->pixelShader);
4228 find_arb_ps_compile_args(ps, This->stateBlock, &compile_args);
4229 compiled = find_arb_pshader(ps, &compile_args);
4230 priv->current_fprogram_id = compiled->prgId;
4231 priv->compiled_fprog = compiled;
4233 /* Bind the fragment program */
4234 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, priv->current_fprogram_id));
4235 checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, priv->current_fprogram_id);");
4237 if(!priv->use_arbfp_fixed_func) {
4238 /* Enable OpenGL fragment programs */
4239 glEnable(GL_FRAGMENT_PROGRAM_ARB);
4240 checkGLcall("glEnable(GL_FRAGMENT_PROGRAM_ARB);");
4242 TRACE("(%p) : Bound fragment program %u and enabled GL_FRAGMENT_PROGRAM_ARB\n", This, priv->current_fprogram_id);
4244 /* Pixel Shader 1.x constants are clamped to [-1;1], Pixel Shader 2.0 constants are not. If switching between
4245 * a 1.x and newer shader, reload the first 8 constants
4247 if(priv->last_ps_const_clamped != ((struct arb_pshader_private *) ps->backend_priv)->clamp_consts)
4249 priv->last_ps_const_clamped = ((struct arb_pshader_private *) ps->backend_priv)->clamp_consts;
4250 This->highest_dirty_ps_const = max(This->highest_dirty_ps_const, 8);
4251 for(i = 0; i < 8; i++)
4253 This->activeContext->pshader_const_dirty[i] = 1;
4255 /* Also takes care of loading local constants */
4256 shader_arb_load_constants(iface, TRUE, FALSE);
4260 shader_arb_ps_local_constants(This);
4263 /* Force constant reloading for the NP2 fixup (see comment in shader_glsl_select for more info) */
4264 if (compiled->np2fixup_info.super.active) This->shader_backend->shader_load_np2fixup_constants(iface, usePS, useVS);
4265 } else if(GL_SUPPORT(ARB_FRAGMENT_PROGRAM) && !priv->use_arbfp_fixed_func) {
4266 /* Disable only if we're not using arbfp fixed function fragment processing. If this is used,
4267 * keep GL_FRAGMENT_PROGRAM_ARB enabled, and the fixed function pipeline will bind the fixed function
4268 * replacement shader
4270 glDisable(GL_FRAGMENT_PROGRAM_ARB);
4271 checkGLcall("glDisable(GL_FRAGMENT_PROGRAM_ARB)");
4272 priv->current_fprogram_id = 0;
4276 struct arb_vs_compile_args compile_args;
4277 struct arb_vs_compiled_shader *compiled;
4278 IWineD3DVertexShaderImpl *vs = (IWineD3DVertexShaderImpl *) This->stateBlock->vertexShader;
4280 TRACE("Using vertex shader %p\n", This->stateBlock->vertexShader);
4281 find_arb_vs_compile_args(vs, This->stateBlock, &compile_args);
4282 compiled = find_arb_vshader(vs, &compile_args);
4283 priv->current_vprogram_id = compiled->prgId;
4284 priv->compiled_vprog = compiled;
4286 /* Bind the vertex program */
4287 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, priv->current_vprogram_id));
4288 checkGLcall("glBindProgramARB(GL_VERTEX_PROGRAM_ARB, priv->current_vprogram_id);");
4290 /* Enable OpenGL vertex programs */
4291 glEnable(GL_VERTEX_PROGRAM_ARB);
4292 checkGLcall("glEnable(GL_VERTEX_PROGRAM_ARB);");
4293 TRACE("(%p) : Bound vertex program %u and enabled GL_VERTEX_PROGRAM_ARB\n", This, priv->current_vprogram_id);
4294 shader_arb_vs_local_constants(This);
4296 if(priv->last_vs_color_unclamp != compiled->need_color_unclamp) {
4297 priv->last_vs_color_unclamp = compiled->need_color_unclamp;
4299 if (GL_SUPPORT(ARB_COLOR_BUFFER_FLOAT)) {
4300 GL_EXTCALL(glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, !compiled->need_color_unclamp));
4301 checkGLcall("glClampColorARB");
4303 FIXME("vertex color clamp needs to be changed, but extension not supported.\n");
4306 } else if(GL_SUPPORT(ARB_VERTEX_PROGRAM)) {
4307 priv->current_vprogram_id = 0;
4308 glDisable(GL_VERTEX_PROGRAM_ARB);
4309 checkGLcall("glDisable(GL_VERTEX_PROGRAM_ARB)");
4313 /* GL locking is done by the caller */
4314 static void shader_arb_select_depth_blt(IWineD3DDevice *iface, enum tex_types tex_type) {
4315 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4316 struct shader_arb_priv *priv = This->shader_priv;
4317 GLuint *blt_fprogram = &priv->depth_blt_fprogram_id[tex_type];
4318 const WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
4320 if (!priv->depth_blt_vprogram_id) priv->depth_blt_vprogram_id = create_arb_blt_vertex_program(gl_info);
4321 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, priv->depth_blt_vprogram_id));
4322 glEnable(GL_VERTEX_PROGRAM_ARB);
4324 if (!*blt_fprogram) *blt_fprogram = create_arb_blt_fragment_program(gl_info, tex_type);
4325 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, *blt_fprogram));
4326 glEnable(GL_FRAGMENT_PROGRAM_ARB);
4329 /* GL locking is done by the caller */
4330 static void shader_arb_deselect_depth_blt(IWineD3DDevice *iface) {
4331 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4332 struct shader_arb_priv *priv = This->shader_priv;
4333 const WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
4335 if (priv->current_vprogram_id) {
4336 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, priv->current_vprogram_id));
4337 checkGLcall("glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vertexShader->prgId);");
4339 TRACE("(%p) : Bound vertex program %u and enabled GL_VERTEX_PROGRAM_ARB\n", This, priv->current_vprogram_id);
4341 glDisable(GL_VERTEX_PROGRAM_ARB);
4342 checkGLcall("glDisable(GL_VERTEX_PROGRAM_ARB)");
4345 if (priv->current_fprogram_id) {
4346 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, priv->current_fprogram_id));
4347 checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, pixelShader->prgId);");
4349 TRACE("(%p) : Bound fragment program %u and enabled GL_FRAGMENT_PROGRAM_ARB\n", This, priv->current_fprogram_id);
4350 } else if(!priv->use_arbfp_fixed_func) {
4351 glDisable(GL_FRAGMENT_PROGRAM_ARB);
4352 checkGLcall("glDisable(GL_FRAGMENT_PROGRAM_ARB)");
4356 static void shader_arb_destroy(IWineD3DBaseShader *iface) {
4357 IWineD3DBaseShaderImpl *baseShader = (IWineD3DBaseShaderImpl *) iface;
4358 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *)baseShader->baseShader.device;
4359 const WineD3D_GL_Info *gl_info = &device->adapter->gl_info;
4361 ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
4363 if (shader_is_pshader_version(baseShader->baseShader.reg_maps.shader_version.type))
4365 IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *) iface;
4366 struct arb_pshader_private *shader_data = This->backend_priv;
4369 if(!shader_data) return; /* This can happen if a shader was never compiled */
4371 for(i = 0; i < shader_data->num_gl_shaders; i++) {
4372 GL_EXTCALL(glDeleteProgramsARB(1, &shader_data->gl_shaders[i].prgId));
4373 checkGLcall("GL_EXTCALL(glDeleteProgramsARB(1, &shader_data->gl_shaders[i].prgId))");
4376 HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders);
4377 HeapFree(GetProcessHeap(), 0, shader_data);
4378 This->backend_priv = NULL;
4380 IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *) iface;
4381 struct arb_vshader_private *shader_data = This->backend_priv;
4384 if(!shader_data) return; /* This can happen if a shader was never compiled */
4386 for(i = 0; i < shader_data->num_gl_shaders; i++) {
4387 GL_EXTCALL(glDeleteProgramsARB(1, &shader_data->gl_shaders[i].prgId));
4388 checkGLcall("GL_EXTCALL(glDeleteProgramsARB(1, &shader_data->gl_shaders[i].prgId))");
4391 HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders);
4392 HeapFree(GetProcessHeap(), 0, shader_data);
4393 This->backend_priv = NULL;
4397 static int sig_tree_compare(const void *key, const struct wine_rb_entry *entry)
4399 struct ps_signature *e = WINE_RB_ENTRY_VALUE(entry, struct ps_signature, entry);
4400 return compare_sig(key, e->sig);
4403 struct wine_rb_functions sig_tree_functions =
4411 static HRESULT shader_arb_alloc(IWineD3DDevice *iface) {
4412 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4413 struct shader_arb_priv *priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*priv));
4414 if(wine_rb_init(&priv->signature_tree, &sig_tree_functions) == -1)
4416 ERR("RB tree init failed\n");
4417 HeapFree(GetProcessHeap(), 0, priv);
4418 return E_OUTOFMEMORY;
4420 This->shader_priv = priv;
4424 static void release_signature(struct wine_rb_entry *entry, void *context)
4426 struct ps_signature *sig = WINE_RB_ENTRY_VALUE(entry, struct ps_signature, entry);
4428 for(i = 0; i < MAX_REG_INPUT; i++)
4430 HeapFree(GetProcessHeap(), 0, (char *) sig->sig[i].semantic_name);
4432 HeapFree(GetProcessHeap(), 0, sig->sig);
4433 HeapFree(GetProcessHeap(), 0, sig);
4436 /* Context activation is done by the caller. */
4437 static void shader_arb_free(IWineD3DDevice *iface) {
4438 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4439 const WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
4440 struct shader_arb_priv *priv = This->shader_priv;
4444 if(priv->depth_blt_vprogram_id) {
4445 GL_EXTCALL(glDeleteProgramsARB(1, &priv->depth_blt_vprogram_id));
4447 for (i = 0; i < tex_type_count; ++i) {
4448 if (priv->depth_blt_fprogram_id[i]) {
4449 GL_EXTCALL(glDeleteProgramsARB(1, &priv->depth_blt_fprogram_id[i]));
4454 wine_rb_destroy(&priv->signature_tree, release_signature, NULL);
4455 HeapFree(GetProcessHeap(), 0, This->shader_priv);
4458 static BOOL shader_arb_dirty_const(IWineD3DDevice *iface) {
4462 static void shader_arb_get_caps(WINED3DDEVTYPE devtype, const WineD3D_GL_Info *gl_info, struct shader_caps *pCaps)
4464 /* We don't have an ARB fixed function pipeline yet, so let the none backend set its caps,
4465 * then overwrite the shader specific ones
4467 none_shader_backend.shader_get_caps(devtype, gl_info, pCaps);
4469 if(GL_SUPPORT(ARB_VERTEX_PROGRAM)) {
4470 if(GL_SUPPORT(NV_VERTEX_PROGRAM3))
4472 pCaps->VertexShaderVersion = WINED3DVS_VERSION(3,0);
4473 TRACE_(d3d_caps)("Hardware vertex shader version 3.0 enabled (NV_VERTEX_PROGRAM3)\n");
4475 else if(GL_LIMITS(vshader_constantsF) >= 256)
4477 /* Shader Model 2.0 requires at least 256 vertex shader constants */
4478 pCaps->VertexShaderVersion = WINED3DVS_VERSION(2,0);
4479 TRACE_(d3d_caps)("Hardware vertex shader version 2.0 enabled (ARB_PROGRAM)\n");
4483 pCaps->VertexShaderVersion = WINED3DVS_VERSION(1,1);
4484 TRACE_(d3d_caps)("Hardware vertex shader version 1.1 enabled (ARB_PROGRAM)\n");
4486 pCaps->MaxVertexShaderConst = GL_LIMITS(vshader_constantsF);
4489 if(GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) {
4490 if(GL_SUPPORT(NV_FRAGMENT_PROGRAM2))
4492 pCaps->PixelShaderVersion = WINED3DPS_VERSION(3,0);
4493 TRACE_(d3d_caps)("Hardware pixel shader version 3.0 enabled (NV_FRAGMENT_PROGRAM2)\n");
4495 else if(GL_LIMITS(vshader_constantsF) >= 32)
4497 /* Shader Model 2.0 requires at least 32 pixel shader constants */
4498 pCaps->PixelShaderVersion = WINED3DPS_VERSION(2,0);
4499 TRACE_(d3d_caps)("Hardware pixel shader version 2.0 enabled (ARB_PROGRAM)\n");
4503 pCaps->PixelShaderVersion = WINED3DPS_VERSION(1,4);
4504 TRACE_(d3d_caps)("Hardware pixel shader version 1.4 enabled (ARB_PROGRAM)\n");
4506 pCaps->PixelShader1xMaxValue = 8.0f;
4507 pCaps->MaxPixelShaderConst = GL_LIMITS(pshader_constantsF);
4510 pCaps->VSClipping = use_nv_clip(gl_info);
4513 static BOOL shader_arb_color_fixup_supported(struct color_fixup_desc fixup)
4515 if (TRACE_ON(d3d_shader) && TRACE_ON(d3d))
4517 TRACE("Checking support for color_fixup:\n");
4518 dump_color_fixup_desc(fixup);
4521 /* We support everything except YUV conversions. */
4522 if (!is_yuv_fixup(fixup))
4528 TRACE("[FAILED]\n");
4532 static void shader_arb_add_instruction_modifiers(const struct wined3d_shader_instruction *ins) {
4534 char write_mask[20], regstr[50];
4535 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
4536 BOOL is_color = FALSE;
4537 const struct wined3d_shader_dst_param *dst;
4539 if (!ins->dst_count) return;
4543 if(shift == 0) return; /* Saturate alone is handled by the instructions */
4545 shader_arb_get_write_mask(ins, dst, write_mask);
4546 shader_arb_get_register_name(ins, &dst->reg, regstr, &is_color);
4548 /* Generate a line that does the output modifier computation
4549 * FIXME: _SAT vs shift? _SAT alone is already handled in the instructions, if this
4550 * maps problems in e.g. _d4_sat modify shader_arb_get_modifier
4552 shader_addline(buffer, "MUL%s %s%s, %s, %s;\n", shader_arb_get_modifier(ins),
4553 regstr, write_mask, regstr, shift_tab[shift]);
4556 static const SHADER_HANDLER shader_arb_instruction_handler_table[WINED3DSIH_TABLE_SIZE] =
4558 /* WINED3DSIH_ABS */ shader_hw_map2gl,
4559 /* WINED3DSIH_ADD */ shader_hw_map2gl,
4560 /* WINED3DSIH_BEM */ pshader_hw_bem,
4561 /* WINED3DSIH_BREAK */ shader_hw_break,
4562 /* WINED3DSIH_BREAKC */ shader_hw_breakc,
4563 /* WINED3DSIH_BREAKP */ NULL,
4564 /* WINED3DSIH_CALL */ shader_hw_call,
4565 /* WINED3DSIH_CALLNZ */ NULL,
4566 /* WINED3DSIH_CMP */ pshader_hw_cmp,
4567 /* WINED3DSIH_CND */ pshader_hw_cnd,
4568 /* WINED3DSIH_CRS */ shader_hw_map2gl,
4569 /* WINED3DSIH_DCL */ NULL,
4570 /* WINED3DSIH_DEF */ NULL,
4571 /* WINED3DSIH_DEFB */ NULL,
4572 /* WINED3DSIH_DEFI */ NULL,
4573 /* WINED3DSIH_DP2ADD */ pshader_hw_dp2add,
4574 /* WINED3DSIH_DP3 */ shader_hw_map2gl,
4575 /* WINED3DSIH_DP4 */ shader_hw_map2gl,
4576 /* WINED3DSIH_DST */ shader_hw_map2gl,
4577 /* WINED3DSIH_DSX */ shader_hw_map2gl,
4578 /* WINED3DSIH_DSY */ shader_hw_dsy,
4579 /* WINED3DSIH_ELSE */ shader_hw_else,
4580 /* WINED3DSIH_ENDIF */ shader_hw_endif,
4581 /* WINED3DSIH_ENDLOOP */ shader_hw_endloop,
4582 /* WINED3DSIH_ENDREP */ shader_hw_endrep,
4583 /* WINED3DSIH_EXP */ shader_hw_map2gl,
4584 /* WINED3DSIH_EXPP */ shader_hw_map2gl,
4585 /* WINED3DSIH_FRC */ shader_hw_map2gl,
4586 /* WINED3DSIH_IF */ NULL /* Hardcoded into the shader */,
4587 /* WINED3DSIH_IFC */ shader_hw_ifc,
4588 /* WINED3DSIH_LABEL */ shader_hw_label,
4589 /* WINED3DSIH_LIT */ shader_hw_map2gl,
4590 /* WINED3DSIH_LOG */ shader_hw_log_pow,
4591 /* WINED3DSIH_LOGP */ shader_hw_log_pow,
4592 /* WINED3DSIH_LOOP */ shader_hw_loop,
4593 /* WINED3DSIH_LRP */ shader_hw_lrp,
4594 /* WINED3DSIH_M3x2 */ shader_hw_mnxn,
4595 /* WINED3DSIH_M3x3 */ shader_hw_mnxn,
4596 /* WINED3DSIH_M3x4 */ shader_hw_mnxn,
4597 /* WINED3DSIH_M4x3 */ shader_hw_mnxn,
4598 /* WINED3DSIH_M4x4 */ shader_hw_mnxn,
4599 /* WINED3DSIH_MAD */ shader_hw_map2gl,
4600 /* WINED3DSIH_MAX */ shader_hw_map2gl,
4601 /* WINED3DSIH_MIN */ shader_hw_map2gl,
4602 /* WINED3DSIH_MOV */ shader_hw_mov,
4603 /* WINED3DSIH_MOVA */ shader_hw_mov,
4604 /* WINED3DSIH_MUL */ shader_hw_map2gl,
4605 /* WINED3DSIH_NOP */ shader_hw_nop,
4606 /* WINED3DSIH_NRM */ shader_hw_nrm,
4607 /* WINED3DSIH_PHASE */ NULL,
4608 /* WINED3DSIH_POW */ shader_hw_log_pow,
4609 /* WINED3DSIH_RCP */ shader_hw_rsq_rcp,
4610 /* WINED3DSIH_REP */ shader_hw_rep,
4611 /* WINED3DSIH_RET */ shader_hw_ret,
4612 /* WINED3DSIH_RSQ */ shader_hw_rsq_rcp,
4613 /* WINED3DSIH_SETP */ NULL,
4614 /* WINED3DSIH_SGE */ shader_hw_map2gl,
4615 /* WINED3DSIH_SGN */ shader_hw_sgn,
4616 /* WINED3DSIH_SINCOS */ shader_hw_sincos,
4617 /* WINED3DSIH_SLT */ shader_hw_map2gl,
4618 /* WINED3DSIH_SUB */ shader_hw_map2gl,
4619 /* WINED3DSIH_TEX */ pshader_hw_tex,
4620 /* WINED3DSIH_TEXBEM */ pshader_hw_texbem,
4621 /* WINED3DSIH_TEXBEML */ pshader_hw_texbem,
4622 /* WINED3DSIH_TEXCOORD */ pshader_hw_texcoord,
4623 /* WINED3DSIH_TEXDEPTH */ pshader_hw_texdepth,
4624 /* WINED3DSIH_TEXDP3 */ pshader_hw_texdp3,
4625 /* WINED3DSIH_TEXDP3TEX */ pshader_hw_texdp3tex,
4626 /* WINED3DSIH_TEXKILL */ pshader_hw_texkill,
4627 /* WINED3DSIH_TEXLDD */ shader_hw_texldd,
4628 /* WINED3DSIH_TEXLDL */ shader_hw_texldl,
4629 /* WINED3DSIH_TEXM3x2DEPTH */ pshader_hw_texm3x2depth,
4630 /* WINED3DSIH_TEXM3x2PAD */ pshader_hw_texm3x2pad,
4631 /* WINED3DSIH_TEXM3x2TEX */ pshader_hw_texm3x2tex,
4632 /* WINED3DSIH_TEXM3x3 */ pshader_hw_texm3x3,
4633 /* WINED3DSIH_TEXM3x3DIFF */ NULL,
4634 /* WINED3DSIH_TEXM3x3PAD */ pshader_hw_texm3x3pad,
4635 /* WINED3DSIH_TEXM3x3SPEC */ pshader_hw_texm3x3spec,
4636 /* WINED3DSIH_TEXM3x3TEX */ pshader_hw_texm3x3tex,
4637 /* WINED3DSIH_TEXM3x3VSPEC */ pshader_hw_texm3x3vspec,
4638 /* WINED3DSIH_TEXREG2AR */ pshader_hw_texreg2ar,
4639 /* WINED3DSIH_TEXREG2GB */ pshader_hw_texreg2gb,
4640 /* WINED3DSIH_TEXREG2RGB */ pshader_hw_texreg2rgb,
4643 static inline BOOL get_bool_const(const struct wined3d_shader_instruction *ins, IWineD3DBaseShaderImpl *This, DWORD idx)
4645 BOOL vshader = shader_is_vshader_version(This->baseShader.reg_maps.shader_version.type);
4647 WORD flag = (1 << idx);
4648 const local_constant *constant;
4649 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
4651 if(This->baseShader.reg_maps.local_bool_consts & flag)
4653 /* What good is a if(bool) with a hardcoded local constant? I don't know, but handle it */
4654 LIST_FOR_EACH_ENTRY(constant, &This->baseShader.constantsB, local_constant, entry)
4656 if (constant->idx == idx)
4658 return constant->value[0];
4661 ERR("Local constant not found\n");
4666 if(vshader) bools = priv->cur_vs_args->boolclip.bools;
4667 else bools = priv->cur_ps_args->bools;
4668 return bools & flag;
4672 static void get_loop_control_const(const struct wined3d_shader_instruction *ins,
4673 IWineD3DBaseShaderImpl *This, UINT idx, struct loop_control *loop_control)
4675 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
4677 /* Integer constants can either be a local constant, or they can be stored in the shader
4678 * type specific compile args. */
4679 if (This->baseShader.reg_maps.local_int_consts & (1 << idx))
4681 const local_constant *constant;
4683 LIST_FOR_EACH_ENTRY(constant, &This->baseShader.constantsI, local_constant, entry)
4685 if (constant->idx == idx)
4687 loop_control->count = constant->value[0];
4688 loop_control->start = constant->value[1];
4689 /* Step is signed. */
4690 loop_control->step = (int)constant->value[2];
4694 /* If this happens the flag was set incorrectly */
4695 ERR("Local constant not found\n");
4696 loop_control->count = 0;
4697 loop_control->start = 0;
4698 loop_control->step = 0;
4702 switch (This->baseShader.reg_maps.shader_version.type)
4704 case WINED3D_SHADER_TYPE_VERTEX:
4705 /* Count and aL start value are unsigned */
4706 loop_control->count = priv->cur_vs_args->loop_ctrl[idx][0];
4707 loop_control->start = priv->cur_vs_args->loop_ctrl[idx][1];
4708 /* Step is signed. */
4709 loop_control->step = ((char)priv->cur_vs_args->loop_ctrl[idx][2]);
4712 case WINED3D_SHADER_TYPE_PIXEL:
4713 loop_control->count = priv->cur_ps_args->loop_ctrl[idx][0];
4714 loop_control->start = priv->cur_ps_args->loop_ctrl[idx][1];
4715 loop_control->step = ((char)priv->cur_ps_args->loop_ctrl[idx][2]);
4719 FIXME("Unhandled shader type %#x.\n", This->baseShader.reg_maps.shader_version.type);
4724 static void record_instruction(struct list *list, const struct wined3d_shader_instruction *ins)
4727 struct wined3d_shader_dst_param *dst_param = NULL;
4728 struct wined3d_shader_src_param *src_param = NULL, *rel_addr = NULL;
4729 struct recorded_instruction *rec = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*rec));
4732 ERR("Out of memory\n");
4737 dst_param = HeapAlloc(GetProcessHeap(), 0, sizeof(*dst_param));
4738 if(!dst_param) goto free;
4739 *dst_param = *ins->dst;
4740 if(ins->dst->reg.rel_addr)
4742 rel_addr = HeapAlloc(GetProcessHeap(), 0, sizeof(*dst_param->reg.rel_addr));
4743 if(!rel_addr) goto free;
4744 *rel_addr = *ins->dst->reg.rel_addr;
4745 dst_param->reg.rel_addr = rel_addr;
4747 rec->ins.dst = dst_param;
4749 src_param = HeapAlloc(GetProcessHeap(), 0, sizeof(*src_param) * ins->src_count);
4750 if(!src_param) goto free;
4751 for(i = 0; i < ins->src_count; i++)
4753 src_param[i] = ins->src[i];
4754 if(ins->src[i].reg.rel_addr)
4756 rel_addr = HeapAlloc(GetProcessHeap(), 0, sizeof(*rel_addr));
4757 if(!rel_addr) goto free;
4758 *rel_addr = *ins->src[i].reg.rel_addr;
4759 src_param[i].reg.rel_addr = rel_addr;
4762 rec->ins.src = src_param;
4763 list_add_tail(list, &rec->entry);
4767 ERR("Out of memory\n");
4770 HeapFree(GetProcessHeap(), 0, (void *) dst_param->reg.rel_addr);
4771 HeapFree(GetProcessHeap(), 0, dst_param);
4775 for(i = 0; i < ins->src_count; i++)
4777 HeapFree(GetProcessHeap(), 0, (void *) src_param[i].reg.rel_addr);
4779 HeapFree(GetProcessHeap(), 0, src_param);
4781 HeapFree(GetProcessHeap(), 0, rec);
4784 static void free_recorded_instruction(struct list *list)
4786 struct recorded_instruction *rec_ins, *entry2;
4789 LIST_FOR_EACH_ENTRY_SAFE(rec_ins, entry2, list, struct recorded_instruction, entry)
4791 list_remove(&rec_ins->entry);
4792 if(rec_ins->ins.dst)
4794 HeapFree(GetProcessHeap(), 0, (void *) rec_ins->ins.dst->reg.rel_addr);
4795 HeapFree(GetProcessHeap(), 0, (void *) rec_ins->ins.dst);
4797 if(rec_ins->ins.src)
4799 for(i = 0; i < rec_ins->ins.src_count; i++)
4801 HeapFree(GetProcessHeap(), 0, (void *) rec_ins->ins.src[i].reg.rel_addr);
4803 HeapFree(GetProcessHeap(), 0, (void *) rec_ins->ins.src);
4805 HeapFree(GetProcessHeap(), 0, rec_ins);
4809 static void shader_arb_handle_instruction(const struct wined3d_shader_instruction *ins) {
4810 SHADER_HANDLER hw_fct;
4811 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
4812 IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
4813 struct control_frame *control_frame;
4814 struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
4817 if(ins->handler_idx == WINED3DSIH_LOOP || ins->handler_idx == WINED3DSIH_REP)
4819 control_frame = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*control_frame));
4820 list_add_head(&priv->control_frames, &control_frame->entry);
4822 if(ins->handler_idx == WINED3DSIH_LOOP) control_frame->type = LOOP;
4823 if(ins->handler_idx == WINED3DSIH_REP) control_frame->type = REP;
4825 if(priv->target_version >= NV2)
4827 control_frame->loop_no = priv->num_loops++;
4832 /* Don't bother recording when we're in a not used if branch */
4838 if(!priv->recording)
4840 list_init(&priv->record);
4841 priv->recording = TRUE;
4842 control_frame->outer_loop = TRUE;
4843 get_loop_control_const(ins, This, ins->src[0].reg.idx, &control_frame->loop_control);
4844 return; /* Instruction is handled */
4846 /* Record this loop in the outer loop's recording */
4849 else if(ins->handler_idx == WINED3DSIH_ENDLOOP || ins->handler_idx == WINED3DSIH_ENDREP)
4851 if(priv->target_version >= NV2)
4853 /* Nothing to do. The control frame is popped after the HW instr handler */
4857 struct list *e = list_head(&priv->control_frames);
4858 control_frame = LIST_ENTRY(e, struct control_frame, entry);
4859 list_remove(&control_frame->entry);
4861 if(control_frame->outer_loop)
4863 int iteration, aL = 0;
4866 /* Turn off recording before playback */
4867 priv->recording = FALSE;
4869 /* Move the recorded instructions to a separate list and get them out of the private data
4870 * structure. If there are nested loops, the shader_arb_handle_instruction below will
4871 * be recorded again, thus priv->record might be overwritten
4874 list_move_tail(©, &priv->record);
4875 list_init(&priv->record);
4877 if(ins->handler_idx == WINED3DSIH_ENDLOOP)
4879 shader_addline(buffer, "#unrolling loop: %u iterations, aL=%u, inc %d\n",
4880 control_frame->loop_control.count, control_frame->loop_control.start,
4881 control_frame->loop_control.step);
4882 aL = control_frame->loop_control.start;
4886 shader_addline(buffer, "#unrolling rep: %u iterations\n", control_frame->loop_control.count);
4889 for (iteration = 0; iteration < control_frame->loop_control.count; ++iteration)
4891 struct recorded_instruction *rec_ins;
4892 if(ins->handler_idx == WINED3DSIH_ENDLOOP)
4895 shader_addline(buffer, "#Iteration %d, aL=%d\n", iteration, aL);
4899 shader_addline(buffer, "#Iteration %d\n", iteration);
4902 LIST_FOR_EACH_ENTRY(rec_ins, ©, struct recorded_instruction, entry)
4904 shader_arb_handle_instruction(&rec_ins->ins);
4907 if(ins->handler_idx == WINED3DSIH_ENDLOOP)
4909 aL += control_frame->loop_control.step;
4912 shader_addline(buffer, "#end loop/rep\n");
4914 free_recorded_instruction(©);
4915 HeapFree(GetProcessHeap(), 0, control_frame);
4916 return; /* Instruction is handled */
4920 /* This is a nested loop. Proceed to the normal recording function */
4921 HeapFree(GetProcessHeap(), 0, control_frame);
4928 record_instruction(&priv->record, ins);
4933 if(ins->handler_idx == WINED3DSIH_IF)
4935 control_frame = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*control_frame));
4936 list_add_head(&priv->control_frames, &control_frame->entry);
4937 control_frame->type = IF;
4939 bool_const = get_bool_const(ins, This, ins->src[0].reg.idx);
4940 if(ins->src[0].modifiers == WINED3DSPSM_NOT) bool_const = !bool_const;
4941 if(!priv->muted && bool_const == FALSE)
4943 shader_addline(buffer, "#if(FALSE){\n");
4945 control_frame->muting = TRUE;
4947 else shader_addline(buffer, "#if(TRUE) {\n");
4949 return; /* Instruction is handled */
4951 else if(ins->handler_idx == WINED3DSIH_IFC)
4953 /* IF(bool) and if_cond(a, b) use the same ELSE and ENDIF tokens */
4954 control_frame = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*control_frame));
4955 control_frame->type = IFC;
4956 control_frame->ifc_no = priv->num_ifcs++;
4957 list_add_head(&priv->control_frames, &control_frame->entry);
4959 else if(ins->handler_idx == WINED3DSIH_ELSE)
4961 struct list *e = list_head(&priv->control_frames);
4962 control_frame = LIST_ENTRY(e, struct control_frame, entry);
4964 if(control_frame->type == IF)
4966 shader_addline(buffer, "#} else {\n");
4967 if(!priv->muted && !control_frame->muting)
4970 control_frame->muting = TRUE;
4972 else if(control_frame->muting) priv->muted = FALSE;
4973 return; /* Instruction is handled. */
4975 /* In case of an ifc, generate a HW shader instruction */
4977 else if(ins->handler_idx == WINED3DSIH_ENDIF)
4979 struct list *e = list_head(&priv->control_frames);
4980 control_frame = LIST_ENTRY(e, struct control_frame, entry);
4982 if(control_frame->type == IF)
4984 shader_addline(buffer, "#} endif\n");
4985 if(control_frame->muting) priv->muted = FALSE;
4986 list_remove(&control_frame->entry);
4987 HeapFree(GetProcessHeap(), 0, control_frame);
4988 return; /* Instruction is handled */
4992 if(priv->muted) return;
4994 /* Select handler */
4995 hw_fct = shader_arb_instruction_handler_table[ins->handler_idx];
4997 /* Unhandled opcode */
5000 FIXME("Backend can't handle opcode %#x\n", ins->handler_idx);
5005 if(ins->handler_idx == WINED3DSIH_ENDLOOP || ins->handler_idx == WINED3DSIH_ENDREP)
5007 struct list *e = list_head(&priv->control_frames);
5008 control_frame = LIST_ENTRY(e, struct control_frame, entry);
5009 list_remove(&control_frame->entry);
5010 HeapFree(GetProcessHeap(), 0, control_frame);
5013 else if(ins->handler_idx == WINED3DSIH_ENDIF)
5015 /* Non-ifc ENDIFs don't reach that place because of the return in the if block above */
5016 struct list *e = list_head(&priv->control_frames);
5017 control_frame = LIST_ENTRY(e, struct control_frame, entry);
5018 list_remove(&control_frame->entry);
5019 HeapFree(GetProcessHeap(), 0, control_frame);
5023 shader_arb_add_instruction_modifiers(ins);
5026 const shader_backend_t arb_program_shader_backend = {
5027 shader_arb_handle_instruction,
5029 shader_arb_select_depth_blt,
5030 shader_arb_deselect_depth_blt,
5031 shader_arb_update_float_vertex_constants,
5032 shader_arb_update_float_pixel_constants,
5033 shader_arb_load_constants,
5034 shader_arb_load_np2fixup_constants,
5038 shader_arb_dirty_const,
5039 shader_arb_get_caps,
5040 shader_arb_color_fixup_supported,
5043 /* ARB_fragment_program fixed function pipeline replacement definitions */
5044 #define ARB_FFP_CONST_TFACTOR 0
5045 #define ARB_FFP_CONST_SPECULAR_ENABLE ((ARB_FFP_CONST_TFACTOR) + 1)
5046 #define ARB_FFP_CONST_CONSTANT(i) ((ARB_FFP_CONST_SPECULAR_ENABLE) + 1 + i)
5047 #define ARB_FFP_CONST_BUMPMAT(i) ((ARB_FFP_CONST_CONSTANT(7)) + 1 + i)
5048 #define ARB_FFP_CONST_LUMINANCE(i) ((ARB_FFP_CONST_BUMPMAT(7)) + 1 + i)
5050 struct arbfp_ffp_desc
5052 struct ffp_frag_desc parent;
5054 unsigned int num_textures_used;
5057 /* Context activation is done by the caller. */
5058 static void arbfp_enable(IWineD3DDevice *iface, BOOL enable) {
5061 glEnable(GL_FRAGMENT_PROGRAM_ARB);
5062 checkGLcall("glEnable(GL_FRAGMENT_PROGRAM_ARB)");
5064 glDisable(GL_FRAGMENT_PROGRAM_ARB);
5065 checkGLcall("glDisable(GL_FRAGMENT_PROGRAM_ARB)");
5070 static HRESULT arbfp_alloc(IWineD3DDevice *iface) {
5071 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
5072 struct shader_arb_priv *priv;
5073 /* Share private data between the shader backend and the pipeline replacement, if both
5074 * are the arb implementation. This is needed to figure out whether ARBfp should be disabled
5075 * if no pixel shader is bound or not
5077 if(This->shader_backend == &arb_program_shader_backend) {
5078 This->fragment_priv = This->shader_priv;
5080 This->fragment_priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct shader_arb_priv));
5081 if(!This->fragment_priv) return E_OUTOFMEMORY;
5083 priv = This->fragment_priv;
5084 if (wine_rb_init(&priv->fragment_shaders, &wined3d_ffp_frag_program_rb_functions) == -1)
5086 ERR("Failed to initialize rbtree.\n");
5087 HeapFree(GetProcessHeap(), 0, This->fragment_priv);
5088 return E_OUTOFMEMORY;
5090 priv->use_arbfp_fixed_func = TRUE;
5094 /* Context activation is done by the caller. */
5095 static void arbfp_free_ffpshader(struct wine_rb_entry *entry, void *context)
5097 const WineD3D_GL_Info *gl_info = context;
5098 struct arbfp_ffp_desc *entry_arb = WINE_RB_ENTRY_VALUE(entry, struct arbfp_ffp_desc, parent.entry);
5101 GL_EXTCALL(glDeleteProgramsARB(1, &entry_arb->shader));
5102 checkGLcall("glDeleteProgramsARB(1, &entry_arb->shader)");
5103 HeapFree(GetProcessHeap(), 0, entry_arb);
5107 /* Context activation is done by the caller. */
5108 static void arbfp_free(IWineD3DDevice *iface) {
5109 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
5110 struct shader_arb_priv *priv = This->fragment_priv;
5112 wine_rb_destroy(&priv->fragment_shaders, arbfp_free_ffpshader, &This->adapter->gl_info);
5113 priv->use_arbfp_fixed_func = FALSE;
5115 if(This->shader_backend != &arb_program_shader_backend) {
5116 HeapFree(GetProcessHeap(), 0, This->fragment_priv);
5120 static void arbfp_get_caps(WINED3DDEVTYPE devtype, const WineD3D_GL_Info *gl_info, struct fragment_caps *caps)
5122 caps->TextureOpCaps = WINED3DTEXOPCAPS_DISABLE |
5123 WINED3DTEXOPCAPS_SELECTARG1 |
5124 WINED3DTEXOPCAPS_SELECTARG2 |
5125 WINED3DTEXOPCAPS_MODULATE4X |
5126 WINED3DTEXOPCAPS_MODULATE2X |
5127 WINED3DTEXOPCAPS_MODULATE |
5128 WINED3DTEXOPCAPS_ADDSIGNED2X |
5129 WINED3DTEXOPCAPS_ADDSIGNED |
5130 WINED3DTEXOPCAPS_ADD |
5131 WINED3DTEXOPCAPS_SUBTRACT |
5132 WINED3DTEXOPCAPS_ADDSMOOTH |
5133 WINED3DTEXOPCAPS_BLENDCURRENTALPHA |
5134 WINED3DTEXOPCAPS_BLENDFACTORALPHA |
5135 WINED3DTEXOPCAPS_BLENDTEXTUREALPHA |
5136 WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA |
5137 WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM |
5138 WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR |
5139 WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
5140 WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA |
5141 WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR |
5142 WINED3DTEXOPCAPS_DOTPRODUCT3 |
5143 WINED3DTEXOPCAPS_MULTIPLYADD |
5144 WINED3DTEXOPCAPS_LERP |
5145 WINED3DTEXOPCAPS_BUMPENVMAP |
5146 WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE;
5148 /* TODO: Implement WINED3DTEXOPCAPS_PREMODULATE */
5150 caps->MaxTextureBlendStages = 8;
5151 caps->MaxSimultaneousTextures = min(GL_LIMITS(fragment_samplers), 8);
5153 caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_TSSARGTEMP;
5155 #undef GLINFO_LOCATION
5157 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
5158 static void state_texfactor_arbfp(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
5160 IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
5162 /* Don't load the parameter if we're using an arbfp pixel shader, otherwise we'll overwrite
5163 * application provided constants
5165 if(device->shader_backend == &arb_program_shader_backend) {
5166 if (use_ps(stateblock)) return;
5168 device = stateblock->wineD3DDevice;
5169 device->activeContext->pshader_const_dirty[ARB_FFP_CONST_TFACTOR] = 1;
5170 device->highest_dirty_ps_const = max(device->highest_dirty_ps_const, ARB_FFP_CONST_TFACTOR + 1);
5173 D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_TEXTUREFACTOR], col);
5174 GL_EXTCALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_TFACTOR, col));
5175 checkGLcall("glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_TFACTOR, col)");
5179 static void state_arb_specularenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
5181 IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
5183 /* Don't load the parameter if we're using an arbfp pixel shader, otherwise we'll overwrite
5184 * application provided constants
5186 if(device->shader_backend == &arb_program_shader_backend) {
5187 if (use_ps(stateblock)) return;
5189 device = stateblock->wineD3DDevice;
5190 device->activeContext->pshader_const_dirty[ARB_FFP_CONST_SPECULAR_ENABLE] = 1;
5191 device->highest_dirty_ps_const = max(device->highest_dirty_ps_const, ARB_FFP_CONST_SPECULAR_ENABLE + 1);
5194 if(stateblock->renderState[WINED3DRS_SPECULARENABLE]) {
5195 /* The specular color has no alpha */
5196 col[0] = 1.0f; col[1] = 1.0f;
5197 col[2] = 1.0f; col[3] = 0.0f;
5199 col[0] = 0.0f; col[1] = 0.0f;
5200 col[2] = 0.0f; col[3] = 0.0f;
5202 GL_EXTCALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_SPECULAR_ENABLE, col));
5203 checkGLcall("glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_SPECULAR_ENABLE, col)");
5206 static void set_bumpmat_arbfp(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
5207 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
5208 IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
5211 if (use_ps(stateblock))
5214 ((IWineD3DPixelShaderImpl *) stateblock->pixelShader)->baseShader.reg_maps.bumpmat[stage]) {
5215 /* The pixel shader has to know the bump env matrix. Do a constants update if it isn't scheduled
5218 if(!isStateDirty(context, STATE_PIXELSHADERCONSTANT)) {
5219 device->StateTable[STATE_PIXELSHADERCONSTANT].apply(STATE_PIXELSHADERCONSTANT, stateblock, context);
5223 if(device->shader_backend == &arb_program_shader_backend) {
5224 /* Exit now, don't set the bumpmat below, otherwise we may overwrite pixel shader constants */
5227 } else if(device->shader_backend == &arb_program_shader_backend) {
5228 device->activeContext->pshader_const_dirty[ARB_FFP_CONST_BUMPMAT(stage)] = 1;
5229 device->highest_dirty_ps_const = max(device->highest_dirty_ps_const, ARB_FFP_CONST_BUMPMAT(stage) + 1);
5232 mat[0][0] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT00]);
5233 mat[0][1] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT01]);
5234 mat[1][0] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT10]);
5235 mat[1][1] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT11]);
5237 GL_EXTCALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_BUMPMAT(stage), &mat[0][0]));
5238 checkGLcall("glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_BUMPMAT(stage), &mat[0][0])");
5241 static void tex_bumpenvlum_arbfp(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
5242 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
5243 IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
5246 if (use_ps(stateblock))
5249 ((IWineD3DPixelShaderImpl *) stateblock->pixelShader)->baseShader.reg_maps.luminanceparams[stage]) {
5250 /* The pixel shader has to know the luminance offset. Do a constants update if it
5251 * isn't scheduled anyway
5253 if(!isStateDirty(context, STATE_PIXELSHADERCONSTANT)) {
5254 device->StateTable[STATE_PIXELSHADERCONSTANT].apply(STATE_PIXELSHADERCONSTANT, stateblock, context);
5258 if(device->shader_backend == &arb_program_shader_backend) {
5259 /* Exit now, don't set the bumpmat below, otherwise we may overwrite pixel shader constants */
5262 } else if(device->shader_backend == &arb_program_shader_backend) {
5263 device->activeContext->pshader_const_dirty[ARB_FFP_CONST_LUMINANCE(stage)] = 1;
5264 device->highest_dirty_ps_const = max(device->highest_dirty_ps_const, ARB_FFP_CONST_LUMINANCE(stage) + 1);
5267 param[0] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVLSCALE]);
5268 param[1] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVLOFFSET]);
5272 GL_EXTCALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_LUMINANCE(stage), param));
5273 checkGLcall("glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_LUMINANCE(stage), param)");
5276 static const char *get_argreg(struct wined3d_shader_buffer *buffer, DWORD argnum, unsigned int stage, DWORD arg)
5280 if(arg == ARG_UNUSED) return "unused"; /* This is the marker for unused registers */
5282 switch(arg & WINED3DTA_SELECTMASK) {
5283 case WINED3DTA_DIFFUSE:
5284 ret = "fragment.color.primary"; break;
5286 case WINED3DTA_CURRENT:
5287 if(stage == 0) ret = "fragment.color.primary";
5291 case WINED3DTA_TEXTURE:
5293 case 0: ret = "tex0"; break;
5294 case 1: ret = "tex1"; break;
5295 case 2: ret = "tex2"; break;
5296 case 3: ret = "tex3"; break;
5297 case 4: ret = "tex4"; break;
5298 case 5: ret = "tex5"; break;
5299 case 6: ret = "tex6"; break;
5300 case 7: ret = "tex7"; break;
5301 default: ret = "unknown texture";
5305 case WINED3DTA_TFACTOR:
5306 ret = "tfactor"; break;
5308 case WINED3DTA_SPECULAR:
5309 ret = "fragment.color.secondary"; break;
5311 case WINED3DTA_TEMP:
5312 ret = "tempreg"; break;
5314 case WINED3DTA_CONSTANT:
5315 FIXME("Implement perstage constants\n");
5317 case 0: ret = "const0"; break;
5318 case 1: ret = "const1"; break;
5319 case 2: ret = "const2"; break;
5320 case 3: ret = "const3"; break;
5321 case 4: ret = "const4"; break;
5322 case 5: ret = "const5"; break;
5323 case 6: ret = "const6"; break;
5324 case 7: ret = "const7"; break;
5325 default: ret = "unknown constant";
5333 if(arg & WINED3DTA_COMPLEMENT) {
5334 shader_addline(buffer, "SUB arg%u, const.x, %s;\n", argnum, ret);
5335 if(argnum == 0) ret = "arg0";
5336 if(argnum == 1) ret = "arg1";
5337 if(argnum == 2) ret = "arg2";
5339 if(arg & WINED3DTA_ALPHAREPLICATE) {
5340 shader_addline(buffer, "MOV arg%u, %s.w;\n", argnum, ret);
5341 if(argnum == 0) ret = "arg0";
5342 if(argnum == 1) ret = "arg1";
5343 if(argnum == 2) ret = "arg2";
5348 static void gen_ffp_instr(struct wined3d_shader_buffer *buffer, unsigned int stage, BOOL color,
5349 BOOL alpha, DWORD dst, DWORD op, DWORD dw_arg0, DWORD dw_arg1, DWORD dw_arg2)
5351 const char *dstmask, *dstreg, *arg0, *arg1, *arg2;
5352 unsigned int mul = 1;
5353 BOOL mul_final_dest = FALSE;
5355 if(color && alpha) dstmask = "";
5356 else if(color) dstmask = ".xyz";
5357 else dstmask = ".w";
5359 if(dst == tempreg) dstreg = "tempreg";
5360 else dstreg = "ret";
5362 arg0 = get_argreg(buffer, 0, stage, dw_arg0);
5363 arg1 = get_argreg(buffer, 1, stage, dw_arg1);
5364 arg2 = get_argreg(buffer, 2, stage, dw_arg2);
5367 case WINED3DTOP_DISABLE:
5368 if(stage == 0) shader_addline(buffer, "MOV %s%s, fragment.color.primary;\n", dstreg, dstmask);
5371 case WINED3DTOP_SELECTARG2:
5373 case WINED3DTOP_SELECTARG1:
5374 shader_addline(buffer, "MOV %s%s, %s;\n", dstreg, dstmask, arg1);
5377 case WINED3DTOP_MODULATE4X:
5379 case WINED3DTOP_MODULATE2X:
5381 if(strcmp(dstreg, "result.color") == 0) {
5383 mul_final_dest = TRUE;
5385 case WINED3DTOP_MODULATE:
5386 shader_addline(buffer, "MUL %s%s, %s, %s;\n", dstreg, dstmask, arg1, arg2);
5389 case WINED3DTOP_ADDSIGNED2X:
5391 if(strcmp(dstreg, "result.color") == 0) {
5393 mul_final_dest = TRUE;
5395 case WINED3DTOP_ADDSIGNED:
5396 shader_addline(buffer, "SUB arg2, %s, const.w;\n", arg2);
5398 case WINED3DTOP_ADD:
5399 shader_addline(buffer, "ADD_SAT %s%s, %s, %s;\n", dstreg, dstmask, arg1, arg2);
5402 case WINED3DTOP_SUBTRACT:
5403 shader_addline(buffer, "SUB_SAT %s%s, %s, %s;\n", dstreg, dstmask, arg1, arg2);
5406 case WINED3DTOP_ADDSMOOTH:
5407 shader_addline(buffer, "SUB arg1, const.x, %s;\n", arg1);
5408 shader_addline(buffer, "MAD_SAT %s%s, arg1, %s, %s;\n", dstreg, dstmask, arg2, arg1);
5411 case WINED3DTOP_BLENDCURRENTALPHA:
5412 arg0 = get_argreg(buffer, 0, stage, WINED3DTA_CURRENT);
5413 shader_addline(buffer, "LRP %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
5415 case WINED3DTOP_BLENDFACTORALPHA:
5416 arg0 = get_argreg(buffer, 0, stage, WINED3DTA_TFACTOR);
5417 shader_addline(buffer, "LRP %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
5419 case WINED3DTOP_BLENDTEXTUREALPHA:
5420 arg0 = get_argreg(buffer, 0, stage, WINED3DTA_TEXTURE);
5421 shader_addline(buffer, "LRP %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
5423 case WINED3DTOP_BLENDDIFFUSEALPHA:
5424 arg0 = get_argreg(buffer, 0, stage, WINED3DTA_DIFFUSE);
5425 shader_addline(buffer, "LRP %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
5428 case WINED3DTOP_BLENDTEXTUREALPHAPM:
5429 arg0 = get_argreg(buffer, 0, stage, WINED3DTA_TEXTURE);
5430 shader_addline(buffer, "SUB arg0.w, const.x, %s.w;\n", arg0);
5431 shader_addline(buffer, "MAD_SAT %s%s, %s, arg0.w, %s;\n", dstreg, dstmask, arg2, arg1);
5434 /* D3DTOP_PREMODULATE ???? */
5436 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
5437 shader_addline(buffer, "SUB arg0.w, const.x, %s;\n", arg1);
5438 shader_addline(buffer, "MAD_SAT %s%s, arg0.w, %s, %s;\n", dstreg, dstmask, arg2, arg1);
5440 case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
5441 shader_addline(buffer, "MAD_SAT %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg1, arg2, arg1);
5443 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
5444 shader_addline(buffer, "SUB arg0, const.x, %s;\n", arg1);
5445 shader_addline(buffer, "MAD_SAT %s%s, arg0, %s, %s.w;\n", dstreg, dstmask, arg2, arg1);
5447 case WINED3DTOP_MODULATECOLOR_ADDALPHA:
5448 shader_addline(buffer, "MAD_SAT %s%s, %s, %s, %s.w;\n", dstreg, dstmask, arg1, arg2, arg1);
5451 case WINED3DTOP_DOTPRODUCT3:
5453 if(strcmp(dstreg, "result.color") == 0) {
5455 mul_final_dest = TRUE;
5457 shader_addline(buffer, "SUB arg1, %s, const.w;\n", arg1);
5458 shader_addline(buffer, "SUB arg2, %s, const.w;\n", arg2);
5459 shader_addline(buffer, "DP3_SAT %s%s, arg1, arg2;\n", dstreg, dstmask);
5462 case WINED3DTOP_MULTIPLYADD:
5463 shader_addline(buffer, "MAD_SAT %s%s, %s, %s, %s;\n", dstreg, dstmask, arg1, arg2, arg0);
5466 case WINED3DTOP_LERP:
5467 /* The msdn is not quite right here */
5468 shader_addline(buffer, "LRP %s%s, %s, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
5471 case WINED3DTOP_BUMPENVMAP:
5472 case WINED3DTOP_BUMPENVMAPLUMINANCE:
5473 /* Those are handled in the first pass of the shader(generation pass 1 and 2) already */
5477 FIXME("Unhandled texture op %08x\n", op);
5481 shader_addline(buffer, "MUL_SAT %s%s, %s, const.y;\n", mul_final_dest ? "result.color" : dstreg, dstmask, dstreg);
5482 } else if(mul == 4) {
5483 shader_addline(buffer, "MUL_SAT %s%s, %s, const.z;\n", mul_final_dest ? "result.color" : dstreg, dstmask, dstreg);
5487 /* The stateblock is passed for GLINFO_LOCATION */
5488 static GLuint gen_arbfp_ffp_shader(const struct ffp_frag_settings *settings, IWineD3DStateBlockImpl *stateblock)
5491 struct wined3d_shader_buffer buffer;
5492 BOOL tex_read[MAX_TEXTURES] = {FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE};
5493 BOOL bump_used[MAX_TEXTURES] = {FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE};
5494 BOOL luminance_used[MAX_TEXTURES] = {FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE};
5495 const char *textype;
5496 const char *instr, *sat;
5497 char colorcor_dst[8];
5499 DWORD arg0, arg1, arg2;
5500 BOOL tempreg_used = FALSE, tfactor_used = FALSE;
5502 const char *final_combiner_src = "ret";
5504 /* Find out which textures are read */
5505 for(stage = 0; stage < MAX_TEXTURES; stage++) {
5506 if(settings->op[stage].cop == WINED3DTOP_DISABLE) break;
5507 arg0 = settings->op[stage].carg0 & WINED3DTA_SELECTMASK;
5508 arg1 = settings->op[stage].carg1 & WINED3DTA_SELECTMASK;
5509 arg2 = settings->op[stage].carg2 & WINED3DTA_SELECTMASK;
5510 if(arg0 == WINED3DTA_TEXTURE) tex_read[stage] = TRUE;
5511 if(arg1 == WINED3DTA_TEXTURE) tex_read[stage] = TRUE;
5512 if(arg2 == WINED3DTA_TEXTURE) tex_read[stage] = TRUE;
5514 if(settings->op[stage].cop == WINED3DTOP_BLENDTEXTUREALPHA) tex_read[stage] = TRUE;
5515 if(settings->op[stage].cop == WINED3DTOP_BLENDTEXTUREALPHAPM) tex_read[stage] = TRUE;
5516 if(settings->op[stage].cop == WINED3DTOP_BUMPENVMAP) {
5517 bump_used[stage] = TRUE;
5518 tex_read[stage] = TRUE;
5520 if(settings->op[stage].cop == WINED3DTOP_BUMPENVMAPLUMINANCE) {
5521 bump_used[stage] = TRUE;
5522 tex_read[stage] = TRUE;
5523 luminance_used[stage] = TRUE;
5524 } else if(settings->op[stage].cop == WINED3DTOP_BLENDFACTORALPHA) {
5525 tfactor_used = TRUE;
5528 if(arg0 == WINED3DTA_TFACTOR || arg1 == WINED3DTA_TFACTOR || arg2 == WINED3DTA_TFACTOR) {
5529 tfactor_used = TRUE;
5532 if(settings->op[stage].dst == tempreg) tempreg_used = TRUE;
5533 if(arg0 == WINED3DTA_TEMP || arg1 == WINED3DTA_TEMP || arg2 == WINED3DTA_TEMP) {
5534 tempreg_used = TRUE;
5537 if(settings->op[stage].aop == WINED3DTOP_DISABLE) continue;
5538 arg0 = settings->op[stage].aarg0 & WINED3DTA_SELECTMASK;
5539 arg1 = settings->op[stage].aarg1 & WINED3DTA_SELECTMASK;
5540 arg2 = settings->op[stage].aarg2 & WINED3DTA_SELECTMASK;
5541 if(arg0 == WINED3DTA_TEXTURE) tex_read[stage] = TRUE;
5542 if(arg1 == WINED3DTA_TEXTURE) tex_read[stage] = TRUE;
5543 if(arg2 == WINED3DTA_TEXTURE) tex_read[stage] = TRUE;
5545 if(arg0 == WINED3DTA_TEMP || arg1 == WINED3DTA_TEMP || arg2 == WINED3DTA_TEMP) {
5546 tempreg_used = TRUE;
5548 if(arg0 == WINED3DTA_TFACTOR || arg1 == WINED3DTA_TFACTOR || arg2 == WINED3DTA_TFACTOR) {
5549 tfactor_used = TRUE;
5554 if (!shader_buffer_init(&buffer))
5556 ERR("Failed to initialize shader buffer.\n");
5560 shader_addline(&buffer, "!!ARBfp1.0\n");
5562 switch(settings->fog) {
5563 case FOG_OFF: break;
5564 case FOG_LINEAR: shader_addline(&buffer, "OPTION ARB_fog_linear;\n"); break;
5565 case FOG_EXP: shader_addline(&buffer, "OPTION ARB_fog_exp;\n"); break;
5566 case FOG_EXP2: shader_addline(&buffer, "OPTION ARB_fog_exp2;\n"); break;
5567 default: FIXME("Unexpected fog setting %d\n", settings->fog);
5570 shader_addline(&buffer, "PARAM const = {1, 2, 4, 0.5};\n");
5571 shader_addline(&buffer, "TEMP TMP;\n");
5572 shader_addline(&buffer, "TEMP ret;\n");
5573 if(tempreg_used || settings->sRGB_write) shader_addline(&buffer, "TEMP tempreg;\n");
5574 shader_addline(&buffer, "TEMP arg0;\n");
5575 shader_addline(&buffer, "TEMP arg1;\n");
5576 shader_addline(&buffer, "TEMP arg2;\n");
5577 for(stage = 0; stage < MAX_TEXTURES; stage++) {
5578 if(!tex_read[stage]) continue;
5579 shader_addline(&buffer, "TEMP tex%u;\n", stage);
5580 if(!bump_used[stage]) continue;
5581 shader_addline(&buffer, "PARAM bumpmat%u = program.env[%u];\n", stage, ARB_FFP_CONST_BUMPMAT(stage));
5582 if(!luminance_used[stage]) continue;
5583 shader_addline(&buffer, "PARAM luminance%u = program.env[%u];\n", stage, ARB_FFP_CONST_LUMINANCE(stage));
5586 shader_addline(&buffer, "PARAM tfactor = program.env[%u];\n", ARB_FFP_CONST_TFACTOR);
5588 shader_addline(&buffer, "PARAM specular_enable = program.env[%u];\n", ARB_FFP_CONST_SPECULAR_ENABLE);
5590 if(settings->sRGB_write) {
5591 shader_addline(&buffer, "PARAM srgb_consts1 = {%f, %f, %f, %f};\n",
5592 srgb_mul_low, srgb_cmp, srgb_pow, srgb_mul_high);
5593 shader_addline(&buffer, "PARAM srgb_consts2 = {%f, %f, %f, %f};\n",
5594 srgb_sub_high, 0.0, 0.0, 0.0);
5597 if(ffp_clip_emul(stateblock) && settings->emul_clipplanes) shader_addline(&buffer, "KIL fragment.texcoord[7];\n");
5599 /* Generate texture sampling instructions) */
5600 for(stage = 0; stage < MAX_TEXTURES && settings->op[stage].cop != WINED3DTOP_DISABLE; stage++) {
5601 if(!tex_read[stage]) continue;
5603 switch(settings->op[stage].tex_type) {
5604 case tex_1d: textype = "1D"; break;
5605 case tex_2d: textype = "2D"; break;
5606 case tex_3d: textype = "3D"; break;
5607 case tex_cube: textype = "CUBE"; break;
5608 case tex_rect: textype = "RECT"; break;
5609 default: textype = "unexpected_textype"; break;
5612 if(settings->op[stage].cop == WINED3DTOP_BUMPENVMAP ||
5613 settings->op[stage].cop == WINED3DTOP_BUMPENVMAPLUMINANCE) {
5619 if(settings->op[stage].projected == proj_none) {
5621 } else if(settings->op[stage].projected == proj_count4 ||
5622 settings->op[stage].projected == proj_count3) {
5625 FIXME("Unexpected projection mode %d\n", settings->op[stage].projected);
5630 (settings->op[stage - 1].cop == WINED3DTOP_BUMPENVMAP ||
5631 settings->op[stage - 1].cop == WINED3DTOP_BUMPENVMAPLUMINANCE)) {
5632 shader_addline(&buffer, "SWZ arg1, bumpmat%u, x, z, 0, 0;\n", stage - 1);
5633 shader_addline(&buffer, "DP3 ret.x, arg1, tex%u;\n", stage - 1);
5634 shader_addline(&buffer, "SWZ arg1, bumpmat%u, y, w, 0, 0;\n", stage - 1);
5635 shader_addline(&buffer, "DP3 ret.y, arg1, tex%u;\n", stage - 1);
5637 /* with projective textures, texbem only divides the static texture coord, not the displacement,
5638 * so multiply the displacement with the dividing parameter before passing it to TXP
5640 if (settings->op[stage].projected != proj_none) {
5641 if(settings->op[stage].projected == proj_count4) {
5642 shader_addline(&buffer, "MOV ret.w, fragment.texcoord[%u].w;\n", stage);
5643 shader_addline(&buffer, "MUL ret.xyz, ret, fragment.texcoord[%u].w, fragment.texcoord[%u];\n", stage, stage);
5645 shader_addline(&buffer, "MOV ret.w, fragment.texcoord[%u].z;\n", stage);
5646 shader_addline(&buffer, "MAD ret.xyz, ret, fragment.texcoord[%u].z, fragment.texcoord[%u];\n", stage, stage);
5649 shader_addline(&buffer, "ADD ret, ret, fragment.texcoord[%u];\n", stage);
5652 shader_addline(&buffer, "%s%s tex%u, ret, texture[%u], %s;\n",
5653 instr, sat, stage, stage, textype);
5654 if(settings->op[stage - 1].cop == WINED3DTOP_BUMPENVMAPLUMINANCE) {
5655 shader_addline(&buffer, "MAD_SAT ret.x, tex%u.z, luminance%u.x, luminance%u.y;\n",
5656 stage - 1, stage - 1, stage - 1);
5657 shader_addline(&buffer, "MUL tex%u, tex%u, ret.x;\n", stage, stage);
5659 } else if(settings->op[stage].projected == proj_count3) {
5660 shader_addline(&buffer, "MOV ret, fragment.texcoord[%u];\n", stage);
5661 shader_addline(&buffer, "MOV ret.w, ret.z;\n");
5662 shader_addline(&buffer, "%s%s tex%u, ret, texture[%u], %s;\n",
5663 instr, sat, stage, stage, textype);
5665 shader_addline(&buffer, "%s%s tex%u, fragment.texcoord[%u], texture[%u], %s;\n",
5666 instr, sat, stage, stage, stage, textype);
5669 sprintf(colorcor_dst, "tex%u", stage);
5670 gen_color_correction(&buffer, colorcor_dst, WINED3DSP_WRITEMASK_ALL, "const.x", "const.y",
5671 settings->op[stage].color_fixup);
5674 /* Generate the main shader */
5675 for(stage = 0; stage < MAX_TEXTURES; stage++) {
5676 if(settings->op[stage].cop == WINED3DTOP_DISABLE) {
5678 final_combiner_src = "fragment.color.primary";
5683 if(settings->op[stage].cop == WINED3DTOP_SELECTARG1 &&
5684 settings->op[stage].aop == WINED3DTOP_SELECTARG1) {
5685 op_equal = settings->op[stage].carg1 == settings->op[stage].aarg1;
5686 } else if(settings->op[stage].cop == WINED3DTOP_SELECTARG1 &&
5687 settings->op[stage].aop == WINED3DTOP_SELECTARG2) {
5688 op_equal = settings->op[stage].carg1 == settings->op[stage].aarg2;
5689 } else if(settings->op[stage].cop == WINED3DTOP_SELECTARG2 &&
5690 settings->op[stage].aop == WINED3DTOP_SELECTARG1) {
5691 op_equal = settings->op[stage].carg2 == settings->op[stage].aarg1;
5692 } else if(settings->op[stage].cop == WINED3DTOP_SELECTARG2 &&
5693 settings->op[stage].aop == WINED3DTOP_SELECTARG2) {
5694 op_equal = settings->op[stage].carg2 == settings->op[stage].aarg2;
5696 op_equal = settings->op[stage].aop == settings->op[stage].cop &&
5697 settings->op[stage].carg0 == settings->op[stage].aarg0 &&
5698 settings->op[stage].carg1 == settings->op[stage].aarg1 &&
5699 settings->op[stage].carg2 == settings->op[stage].aarg2;
5702 if(settings->op[stage].aop == WINED3DTOP_DISABLE) {
5703 gen_ffp_instr(&buffer, stage, TRUE, FALSE, settings->op[stage].dst,
5704 settings->op[stage].cop, settings->op[stage].carg0,
5705 settings->op[stage].carg1, settings->op[stage].carg2);
5707 shader_addline(&buffer, "MOV ret.w, fragment.color.primary.w;\n");
5709 } else if(op_equal) {
5710 gen_ffp_instr(&buffer, stage, TRUE, TRUE, settings->op[stage].dst,
5711 settings->op[stage].cop, settings->op[stage].carg0,
5712 settings->op[stage].carg1, settings->op[stage].carg2);
5714 gen_ffp_instr(&buffer, stage, TRUE, FALSE, settings->op[stage].dst,
5715 settings->op[stage].cop, settings->op[stage].carg0,
5716 settings->op[stage].carg1, settings->op[stage].carg2);
5717 gen_ffp_instr(&buffer, stage, FALSE, TRUE, settings->op[stage].dst,
5718 settings->op[stage].aop, settings->op[stage].aarg0,
5719 settings->op[stage].aarg1, settings->op[stage].aarg2);
5723 if(settings->sRGB_write) {
5724 shader_addline(&buffer, "MAD ret, fragment.color.secondary, specular_enable, %s;\n", final_combiner_src);
5725 arbfp_add_sRGB_correction(&buffer, "ret", "arg0", "arg1", "arg2", "tempreg", FALSE);
5727 shader_addline(&buffer, "MAD result.color, fragment.color.secondary, specular_enable, %s;\n", final_combiner_src);
5731 shader_addline(&buffer, "END\n");
5733 /* Generate the shader */
5734 GL_EXTCALL(glGenProgramsARB(1, &ret));
5735 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, ret));
5736 GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(buffer.buffer), buffer.buffer));
5738 if (glGetError() == GL_INVALID_OPERATION) {
5740 glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
5741 FIXME("Fragment program error at position %d: %s\n", pos,
5742 debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
5744 shader_buffer_free(&buffer);
5748 static void fragment_prog_arbfp(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
5749 IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
5750 struct shader_arb_priv *priv = device->fragment_priv;
5751 BOOL use_pshader = use_ps(stateblock);
5752 BOOL use_vshader = use_vs(stateblock);
5753 struct ffp_frag_settings settings;
5754 const struct arbfp_ffp_desc *desc;
5757 TRACE("state %#x, stateblock %p, context %p\n", state, stateblock, context);
5759 if(isStateDirty(context, STATE_RENDER(WINED3DRS_FOGENABLE))) {
5760 if(!use_pshader && device->shader_backend == &arb_program_shader_backend && context->last_was_pshader) {
5761 /* Reload fixed function constants since they collide with the pixel shader constants */
5762 for(i = 0; i < MAX_TEXTURES; i++) {
5763 set_bumpmat_arbfp(STATE_TEXTURESTAGE(i, WINED3DTSS_BUMPENVMAT00), stateblock, context);
5765 state_texfactor_arbfp(STATE_RENDER(WINED3DRS_TEXTUREFACTOR), stateblock, context);
5766 state_arb_specularenable(STATE_RENDER(WINED3DRS_SPECULARENABLE), stateblock, context);
5767 } else if(use_pshader && !isStateDirty(context, device->StateTable[STATE_VSHADER].representative)) {
5768 device->shader_backend->shader_select((IWineD3DDevice *)stateblock->wineD3DDevice, use_pshader, use_vshader);
5774 /* Find or create a shader implementing the fixed function pipeline settings, then activate it */
5775 gen_ffp_frag_op(stateblock, &settings, FALSE);
5776 desc = (const struct arbfp_ffp_desc *)find_ffp_frag_shader(&priv->fragment_shaders, &settings);
5778 struct arbfp_ffp_desc *new_desc = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_desc));
5781 ERR("Out of memory\n");
5784 new_desc->num_textures_used = 0;
5785 for(i = 0; i < GL_LIMITS(texture_stages); i++) {
5786 if(settings.op[i].cop == WINED3DTOP_DISABLE) break;
5787 new_desc->num_textures_used = i;
5790 memcpy(&new_desc->parent.settings, &settings, sizeof(settings));
5791 new_desc->shader = gen_arbfp_ffp_shader(&settings, stateblock);
5792 add_ffp_frag_shader(&priv->fragment_shaders, &new_desc->parent);
5793 TRACE("Allocated fixed function replacement shader descriptor %p\n", new_desc);
5797 /* Now activate the replacement program. GL_FRAGMENT_PROGRAM_ARB is already active(however, note the
5798 * comment above the shader_select call below). If e.g. GLSL is active, the shader_select call will
5801 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, desc->shader));
5802 checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, desc->shader)");
5803 priv->current_fprogram_id = desc->shader;
5805 if(device->shader_backend == &arb_program_shader_backend && context->last_was_pshader) {
5806 /* Reload fixed function constants since they collide with the pixel shader constants */
5807 for(i = 0; i < MAX_TEXTURES; i++) {
5808 set_bumpmat_arbfp(STATE_TEXTURESTAGE(i, WINED3DTSS_BUMPENVMAT00), stateblock, context);
5810 state_texfactor_arbfp(STATE_RENDER(WINED3DRS_TEXTUREFACTOR), stateblock, context);
5811 state_arb_specularenable(STATE_RENDER(WINED3DRS_SPECULARENABLE), stateblock, context);
5813 context->last_was_pshader = FALSE;
5815 context->last_was_pshader = TRUE;
5818 /* Finally, select the shader. If a pixel shader is used, it will be set and enabled by the shader backend.
5819 * If this shader backend is arbfp(most likely), then it will simply overwrite the last fixed function replace-
5820 * ment shader. If the shader backend is not ARB, it currently is important that the opengl implementation
5821 * type overwrites GL_ARB_fragment_program. This is currently the case with GLSL. If we really want to use
5822 * atifs or nvrc pixel shaders with arb fragment programs we'd have to disable GL_FRAGMENT_PROGRAM_ARB here
5824 * Don't call shader_select if the vertex shader is dirty, because it will be called later on by the vertex
5827 if(!isStateDirty(context, device->StateTable[STATE_VSHADER].representative)) {
5828 device->shader_backend->shader_select((IWineD3DDevice *)stateblock->wineD3DDevice, use_pshader, use_vshader);
5830 if (!isStateDirty(context, STATE_VERTEXSHADERCONSTANT) && (use_vshader || use_pshader)) {
5831 device->StateTable[STATE_VERTEXSHADERCONSTANT].apply(STATE_VERTEXSHADERCONSTANT, stateblock, context);
5835 device->StateTable[STATE_PIXELSHADERCONSTANT].apply(STATE_PIXELSHADERCONSTANT, stateblock, context);
5839 /* We can't link the fog states to the fragment state directly since the vertex pipeline links them
5840 * to FOGENABLE. A different linking in different pipeline parts can't be expressed in the combined
5841 * state table, so we need to handle that with a forwarding function. The other invisible side effect
5842 * is that changing the fog start and fog end(which links to FOGENABLE in vertex) results in the
5843 * fragment_prog_arbfp function being called because FOGENABLE is dirty, which calls this function here
5845 static void state_arbfp_fog(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
5846 enum fogsource new_source;
5848 TRACE("state %#x, stateblock %p, context %p\n", state, stateblock, context);
5850 if(!isStateDirty(context, STATE_PIXELSHADER)) {
5851 fragment_prog_arbfp(state, stateblock, context);
5854 if(!stateblock->renderState[WINED3DRS_FOGENABLE]) return;
5856 if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE) {
5857 if(use_vs(stateblock)) {
5858 new_source = FOGSOURCE_VS;
5860 if(stateblock->renderState[WINED3DRS_FOGVERTEXMODE] == WINED3DFOG_NONE || context->last_was_rhw) {
5861 new_source = FOGSOURCE_COORD;
5863 new_source = FOGSOURCE_FFP;
5867 new_source = FOGSOURCE_FFP;
5869 if(new_source != context->fog_source) {
5870 context->fog_source = new_source;
5871 state_fogstartend(STATE_RENDER(WINED3DRS_FOGSTART), stateblock, context);
5875 static void textransform(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
5876 if(!isStateDirty(context, STATE_PIXELSHADER)) {
5877 fragment_prog_arbfp(state, stateblock, context);
5881 #undef GLINFO_LOCATION
5883 static const struct StateEntryTemplate arbfp_fragmentstate_template[] = {
5884 {STATE_RENDER(WINED3DRS_TEXTUREFACTOR), { STATE_RENDER(WINED3DRS_TEXTUREFACTOR), state_texfactor_arbfp }, WINED3D_GL_EXT_NONE },
5885 {STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5886 {STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG1), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5887 {STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG2), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5888 {STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG0), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5889 {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5890 {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG1), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5891 {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG2), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5892 {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG0), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5893 {STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5894 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5895 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5896 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5897 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5898 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
5899 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
5900 {STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5901 {STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG1), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5902 {STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG2), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5903 {STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG0), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5904 {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5905 {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG1), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5906 {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG2), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5907 {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG0), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5908 {STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5909 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5910 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5911 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5912 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5913 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
5914 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
5915 {STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5916 {STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG1), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5917 {STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG2), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5918 {STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG0), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5919 {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5920 {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG1), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5921 {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG2), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5922 {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG0), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5923 {STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5924 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5925 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5926 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5927 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5928 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
5929 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
5930 {STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5931 {STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG1), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5932 {STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG2), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5933 {STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG0), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5934 {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5935 {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG1), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5936 {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG2), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5937 {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG0), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5938 {STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5939 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5940 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5941 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5942 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5943 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
5944 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
5945 {STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5946 {STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG1), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5947 {STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG2), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5948 {STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG0), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5949 {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5950 {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG1), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5951 {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG2), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5952 {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG0), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5953 {STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5954 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5955 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5956 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5957 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5958 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
5959 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
5960 {STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5961 {STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG1), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5962 {STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG2), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5963 {STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG0), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5964 {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5965 {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG1), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5966 {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG2), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5967 {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG0), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5968 {STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5969 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5970 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5971 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5972 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5973 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
5974 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
5975 {STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5976 {STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG1), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5977 {STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG2), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5978 {STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG0), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5979 {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5980 {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG1), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5981 {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG2), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5982 {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG0), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5983 {STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5984 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5985 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5986 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5987 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
5988 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
5989 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
5990 {STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5991 {STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG1), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5992 {STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG2), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5993 {STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG0), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5994 {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5995 {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG1), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5996 {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG2), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5997 {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG0), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5998 {STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
5999 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
6000 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
6001 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
6002 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), set_bumpmat_arbfp }, WINED3D_GL_EXT_NONE },
6003 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
6004 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlum_arbfp }, WINED3D_GL_EXT_NONE },
6005 {STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim }, WINED3D_GL_EXT_NONE },
6006 {STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim }, WINED3D_GL_EXT_NONE },
6007 {STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim }, WINED3D_GL_EXT_NONE },
6008 {STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texdim }, WINED3D_GL_EXT_NONE },
6009 {STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texdim }, WINED3D_GL_EXT_NONE },
6010 {STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texdim }, WINED3D_GL_EXT_NONE },
6011 {STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texdim }, WINED3D_GL_EXT_NONE },
6012 {STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texdim }, WINED3D_GL_EXT_NONE },
6013 {STATE_PIXELSHADER, { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
6014 {STATE_RENDER(WINED3DRS_FOGENABLE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_arbfp_fog }, WINED3D_GL_EXT_NONE },
6015 {STATE_RENDER(WINED3DRS_FOGTABLEMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_arbfp_fog }, WINED3D_GL_EXT_NONE },
6016 {STATE_RENDER(WINED3DRS_FOGVERTEXMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_arbfp_fog }, WINED3D_GL_EXT_NONE },
6017 {STATE_RENDER(WINED3DRS_FOGSTART), { STATE_RENDER(WINED3DRS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
6018 {STATE_RENDER(WINED3DRS_FOGEND), { STATE_RENDER(WINED3DRS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
6019 {STATE_RENDER(WINED3DRS_SRGBWRITEENABLE), { STATE_PIXELSHADER, fragment_prog_arbfp }, WINED3D_GL_EXT_NONE },
6020 {STATE_RENDER(WINED3DRS_FOGCOLOR), { STATE_RENDER(WINED3DRS_FOGCOLOR), state_fogcolor }, WINED3D_GL_EXT_NONE },
6021 {STATE_RENDER(WINED3DRS_FOGDENSITY), { STATE_RENDER(WINED3DRS_FOGDENSITY), state_fogdensity }, WINED3D_GL_EXT_NONE },
6022 {STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(0, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform }, WINED3D_GL_EXT_NONE },
6023 {STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(1, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform }, WINED3D_GL_EXT_NONE },
6024 {STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(2, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform }, WINED3D_GL_EXT_NONE },
6025 {STATE_TEXTURESTAGE(3,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(3, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform }, WINED3D_GL_EXT_NONE },
6026 {STATE_TEXTURESTAGE(4,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(4, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform }, WINED3D_GL_EXT_NONE },
6027 {STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(5, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform }, WINED3D_GL_EXT_NONE },
6028 {STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(6, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform }, WINED3D_GL_EXT_NONE },
6029 {STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(7, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform }, WINED3D_GL_EXT_NONE },
6030 {STATE_RENDER(WINED3DRS_SPECULARENABLE), { STATE_RENDER(WINED3DRS_SPECULARENABLE), state_arb_specularenable}, WINED3D_GL_EXT_NONE },
6031 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE },
6034 const struct fragment_pipeline arbfp_fragment_pipeline = {
6039 shader_arb_color_fixup_supported,
6040 arbfp_fragmentstate_template,
6041 TRUE /* We can disable projected textures */
6044 #define GLINFO_LOCATION device->adapter->gl_info
6046 struct arbfp_blit_priv {
6047 GLenum yuy2_rect_shader, yuy2_2d_shader;
6048 GLenum uyvy_rect_shader, uyvy_2d_shader;
6049 GLenum yv12_rect_shader, yv12_2d_shader;
6052 static HRESULT arbfp_blit_alloc(IWineD3DDevice *iface) {
6053 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) iface;
6054 device->blit_priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct arbfp_blit_priv));
6055 if(!device->blit_priv) {
6056 ERR("Out of memory\n");
6057 return E_OUTOFMEMORY;
6062 /* Context activation is done by the caller. */
6063 static void arbfp_blit_free(IWineD3DDevice *iface) {
6064 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) iface;
6065 struct arbfp_blit_priv *priv = device->blit_priv;
6068 GL_EXTCALL(glDeleteProgramsARB(1, &priv->yuy2_rect_shader));
6069 GL_EXTCALL(glDeleteProgramsARB(1, &priv->yuy2_2d_shader));
6070 GL_EXTCALL(glDeleteProgramsARB(1, &priv->uyvy_rect_shader));
6071 GL_EXTCALL(glDeleteProgramsARB(1, &priv->uyvy_2d_shader));
6072 GL_EXTCALL(glDeleteProgramsARB(1, &priv->yv12_rect_shader));
6073 GL_EXTCALL(glDeleteProgramsARB(1, &priv->yv12_2d_shader));
6074 checkGLcall("Delete yuv programs");
6078 static BOOL gen_planar_yuv_read(struct wined3d_shader_buffer *buffer, enum yuv_fixup yuv_fixup,
6079 GLenum textype, char *luminance)
6082 const char *tex, *texinstr;
6084 if (yuv_fixup == YUV_FIXUP_UYVY) {
6092 case GL_TEXTURE_2D: tex = "2D"; texinstr = "TXP"; break;
6093 case GL_TEXTURE_RECTANGLE_ARB: tex = "RECT"; texinstr = "TEX"; break;
6095 /* This is more tricky than just replacing the texture type - we have to navigate
6096 * properly in the texture to find the correct chroma values
6098 FIXME("Implement yuv correction for non-2d, non-rect textures\n");
6102 /* First we have to read the chroma values. This means we need at least two pixels(no filtering),
6103 * or 4 pixels(with filtering). To get the unmodified chromas, we have to rid ourselves of the
6104 * filtering when we sample the texture.
6106 * These are the rules for reading the chroma:
6112 * So we have to get the sampling x position in non-normalized coordinates in integers
6114 if(textype != GL_TEXTURE_RECTANGLE_ARB) {
6115 shader_addline(buffer, "MUL texcrd.xy, fragment.texcoord[0], size.x;\n");
6116 shader_addline(buffer, "MOV texcrd.w, size.x;\n");
6118 shader_addline(buffer, "MOV texcrd, fragment.texcoord[0];\n");
6120 /* We must not allow filtering between pixel x and x+1, this would mix U and V
6121 * Vertical filtering is ok. However, bear in mind that the pixel center is at
6124 shader_addline(buffer, "FLR texcrd.x, texcrd.x;\n");
6125 shader_addline(buffer, "ADD texcrd.x, texcrd.x, coef.y;\n");
6127 /* Divide the x coordinate by 0.5 and get the fraction. This gives 0.25 and 0.75 for the
6128 * even and odd pixels respectively
6130 shader_addline(buffer, "MUL texcrd2, texcrd, coef.y;\n");
6131 shader_addline(buffer, "FRC texcrd2, texcrd2;\n");
6133 /* Sample Pixel 1 */
6134 shader_addline(buffer, "%s luminance, texcrd, texture[0], %s;\n", texinstr, tex);
6136 /* Put the value into either of the chroma values */
6137 shader_addline(buffer, "SGE temp.x, texcrd2.x, coef.y;\n");
6138 shader_addline(buffer, "MUL chroma.x, luminance.%c, temp.x;\n", chroma);
6139 shader_addline(buffer, "SLT temp.x, texcrd2.x, coef.y;\n");
6140 shader_addline(buffer, "MUL chroma.y, luminance.%c, temp.x;\n", chroma);
6142 /* Sample pixel 2. If we read an even pixel(SLT above returned 1), sample
6143 * the pixel right to the current one. Otherwise, sample the left pixel.
6144 * Bias and scale the SLT result to -1;1 and add it to the texcrd.x.
6146 shader_addline(buffer, "MAD temp.x, temp.x, coef.z, -coef.x;\n");
6147 shader_addline(buffer, "ADD texcrd.x, texcrd, temp.x;\n");
6148 shader_addline(buffer, "%s luminance, texcrd, texture[0], %s;\n", texinstr, tex);
6150 /* Put the value into the other chroma */
6151 shader_addline(buffer, "SGE temp.x, texcrd2.x, coef.y;\n");
6152 shader_addline(buffer, "MAD chroma.y, luminance.%c, temp.x, chroma.y;\n", chroma);
6153 shader_addline(buffer, "SLT temp.x, texcrd2.x, coef.y;\n");
6154 shader_addline(buffer, "MAD chroma.x, luminance.%c, temp.x, chroma.x;\n", chroma);
6156 /* TODO: If filtering is enabled, sample a 2nd pair of pixels left or right of
6157 * the current one and lerp the two U and V values
6160 /* This gives the correctly filtered luminance value */
6161 shader_addline(buffer, "TEX luminance, fragment.texcoord[0], texture[0], %s;\n", tex);
6166 static BOOL gen_yv12_read(struct wined3d_shader_buffer *buffer, GLenum textype, char *luminance)
6171 case GL_TEXTURE_2D: tex = "2D"; break;
6172 case GL_TEXTURE_RECTANGLE_ARB: tex = "RECT"; break;
6174 FIXME("Implement yv12 correction for non-2d, non-rect textures\n");
6178 /* YV12 surfaces contain a WxH sized luminance plane, followed by a (W/2)x(H/2)
6179 * V and a (W/2)x(H/2) U plane, each with 8 bit per pixel. So the effective
6180 * bitdepth is 12 bits per pixel. Since the U and V planes have only half the
6181 * pitch of the luminance plane, the packing into the gl texture is a bit
6182 * unfortunate. If the whole texture is interpreted as luminance data it looks
6183 * approximately like this:
6185 * +----------------------------------+----
6197 * +----------------+-----------------+----
6199 * | U even rows | U odd rows |
6201 * +----------------+------------------ -
6203 * | V even rows | V odd rows |
6205 * +----------------+-----------------+----
6209 * So it appears as if there are 4 chroma images, but in fact the odd rows
6210 * in the chroma images are in the same row as the even ones. So its is
6211 * kinda tricky to read
6213 * When reading from rectangle textures, keep in mind that the input y coordinates
6214 * go from 0 to d3d_height, whereas the opengl texture height is 1.5 * d3d_height
6216 shader_addline(buffer, "PARAM yv12_coef = {%f, %f, %f, %f};\n",
6217 2.0f / 3.0f, 1.0f / 6.0f, (2.0f / 3.0f) + (1.0f / 6.0f), 1.0f / 3.0f);
6219 shader_addline(buffer, "MOV texcrd, fragment.texcoord[0];\n");
6220 /* the chroma planes have only half the width */
6221 shader_addline(buffer, "MUL texcrd.x, texcrd.x, coef.y;\n");
6223 /* The first value is between 2/3 and 5/6th of the texture's height, so scale+bias
6224 * the coordinate. Also read the right side of the image when reading odd lines
6226 * Don't forget to clamp the y values in into the range, otherwise we'll get filtering
6229 if(textype == GL_TEXTURE_2D) {
6231 shader_addline(buffer, "RCP chroma.w, size.y;\n");
6233 shader_addline(buffer, "MUL texcrd2.y, texcrd.y, size.y;\n");
6235 shader_addline(buffer, "FLR texcrd2.y, texcrd2.y;\n");
6236 shader_addline(buffer, "MAD texcrd.y, texcrd.y, yv12_coef.y, yv12_coef.x;\n");
6238 /* Read odd lines from the right side(add size * 0.5 to the x coordinate */
6239 shader_addline(buffer, "ADD texcrd2.x, texcrd2.y, yv12_coef.y;\n"); /* To avoid 0.5 == 0.5 comparisons */
6240 shader_addline(buffer, "FRC texcrd2.x, texcrd2.x;\n");
6241 shader_addline(buffer, "SGE texcrd2.x, texcrd2.x, coef.y;\n");
6242 shader_addline(buffer, "MAD texcrd.x, texcrd2.x, coef.y, texcrd.x;\n");
6244 /* clamp, keep the half pixel origin in mind */
6245 shader_addline(buffer, "MAD temp.y, coef.y, chroma.w, yv12_coef.x;\n");
6246 shader_addline(buffer, "MAX texcrd.y, temp.y, texcrd.y;\n");
6247 shader_addline(buffer, "MAD temp.y, -coef.y, chroma.w, yv12_coef.z;\n");
6248 shader_addline(buffer, "MIN texcrd.y, temp.y, texcrd.y;\n");
6250 /* Read from [size - size+size/4] */
6251 shader_addline(buffer, "FLR texcrd.y, texcrd.y;\n");
6252 shader_addline(buffer, "MAD texcrd.y, texcrd.y, coef.w, size.y;\n");
6254 /* Read odd lines from the right side(add size * 0.5 to the x coordinate */
6255 shader_addline(buffer, "ADD texcrd2.x, texcrd.y, yv12_coef.y;\n"); /* To avoid 0.5 == 0.5 comparisons */
6256 shader_addline(buffer, "FRC texcrd2.x, texcrd2.x;\n");
6257 shader_addline(buffer, "SGE texcrd2.x, texcrd2.x, coef.y;\n");
6258 shader_addline(buffer, "MUL texcrd2.x, texcrd2.x, size.x;\n");
6259 shader_addline(buffer, "MAD texcrd.x, texcrd2.x, coef.y, texcrd.x;\n");
6261 /* Make sure to read exactly from the pixel center */
6262 shader_addline(buffer, "FLR texcrd.y, texcrd.y;\n");
6263 shader_addline(buffer, "ADD texcrd.y, texcrd.y, coef.y;\n");
6266 shader_addline(buffer, "MAD temp.y, size.y, coef.w, size.y;\n");
6267 shader_addline(buffer, "ADD temp.y, temp.y, -coef.y;\n");
6268 shader_addline(buffer, "MIN texcrd.y, temp.y, texcrd.y;\n");
6269 shader_addline(buffer, "ADD temp.y, size.y, -coef.y;\n");
6270 shader_addline(buffer, "MAX texcrd.y, temp.y, texcrd.y;\n");
6272 /* Read the texture, put the result into the output register */
6273 shader_addline(buffer, "TEX temp, texcrd, texture[0], %s;\n", tex);
6274 shader_addline(buffer, "MOV chroma.x, temp.w;\n");
6276 /* The other chroma value is 1/6th of the texture lower, from 5/6th to 6/6th
6277 * No need to clamp because we're just reusing the already clamped value from above
6279 if(textype == GL_TEXTURE_2D) {
6280 shader_addline(buffer, "ADD texcrd.y, texcrd.y, yv12_coef.y;\n");
6282 shader_addline(buffer, "MAD texcrd.y, size.y, coef.w, texcrd.y;\n");
6284 shader_addline(buffer, "TEX temp, texcrd, texture[0], %s;\n", tex);
6285 shader_addline(buffer, "MOV chroma.y, temp.w;\n");
6287 /* Sample the luminance value. It is in the top 2/3rd of the texture, so scale the y coordinate.
6288 * Clamp the y coordinate to prevent the chroma values from bleeding into the sampled luminance
6289 * values due to filtering
6291 shader_addline(buffer, "MOV texcrd, fragment.texcoord[0];\n");
6292 if(textype == GL_TEXTURE_2D) {
6293 /* Multiply the y coordinate by 2/3 and clamp it */
6294 shader_addline(buffer, "MUL texcrd.y, texcrd.y, yv12_coef.x;\n");
6295 shader_addline(buffer, "MAD temp.y, -coef.y, chroma.w, yv12_coef.x;\n");
6296 shader_addline(buffer, "MIN texcrd.y, temp.y, texcrd.y;\n");
6297 shader_addline(buffer, "TEX luminance, texcrd, texture[0], %s;\n", tex);
6299 /* Reading from texture_rectangles is pretty straightforward, just use the unmodified
6300 * texture coordinate. It is still a good idea to clamp it though, since the opengl texture
6303 shader_addline(buffer, "ADD temp.x, size.y, -coef.y;\n");
6304 shader_addline(buffer, "MIN texcrd.y, texcrd.y, size.x;\n");
6305 shader_addline(buffer, "TEX luminance, texcrd, texture[0], %s;\n", tex);
6312 /* Context activation is done by the caller. */
6313 static GLuint gen_yuv_shader(IWineD3DDeviceImpl *device, enum yuv_fixup yuv_fixup, GLenum textype)
6316 struct wined3d_shader_buffer buffer;
6317 char luminance_component;
6318 struct arbfp_blit_priv *priv = device->blit_priv;
6321 if (!shader_buffer_init(&buffer))
6323 ERR("Failed to initialize shader buffer.\n");
6328 GL_EXTCALL(glGenProgramsARB(1, &shader));
6329 checkGLcall("GL_EXTCALL(glGenProgramsARB(1, &shader))");
6330 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader));
6331 checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader)");
6334 shader_buffer_free(&buffer);
6338 /* The YUY2 and UYVY formats contain two pixels packed into a 32 bit macropixel,
6339 * giving effectively 16 bit per pixel. The color consists of a luminance(Y) and
6340 * two chroma(U and V) values. Each macropixel has two luminance values, one for
6341 * each single pixel it contains, and one U and one V value shared between both
6344 * The data is loaded into an A8L8 texture. With YUY2, the luminance component
6345 * contains the luminance and alpha the chroma. With UYVY it is vice versa. Thus
6346 * take the format into account when generating the read swizzles
6348 * Reading the Y value is straightforward - just sample the texture. The hardware
6349 * takes care of filtering in the horizontal and vertical direction.
6351 * Reading the U and V values is harder. We have to avoid filtering horizontally,
6352 * because that would mix the U and V values of one pixel or two adjacent pixels.
6353 * Thus floor the texture coordinate and add 0.5 to get an unfiltered read,
6354 * regardless of the filtering setting. Vertical filtering works automatically
6355 * though - the U and V values of two rows are mixed nicely.
6357 * Appart of avoiding filtering issues, the code has to know which value it just
6358 * read, and where it can find the other one. To determine this, it checks if
6359 * it sampled an even or odd pixel, and shifts the 2nd read accordingly.
6361 * Handling horizontal filtering of U and V values requires reading a 2nd pair
6362 * of pixels, extracting U and V and mixing them. This is not implemented yet.
6364 * An alternative implementation idea is to load the texture as A8R8G8B8 texture,
6365 * with width / 2. This way one read gives all 3 values, finding U and V is easy
6366 * in an unfiltered situation. Finding the luminance on the other hand requires
6367 * finding out if it is an odd or even pixel. The real drawback of this approach
6368 * is filtering. This would have to be emulated completely in the shader, reading
6369 * up two 2 packed pixels in up to 2 rows and interpolating both horizontally and
6370 * vertically. Beyond that it would require adjustments to the texture handling
6371 * code to deal with the width scaling
6373 shader_addline(&buffer, "!!ARBfp1.0\n");
6374 shader_addline(&buffer, "TEMP luminance;\n");
6375 shader_addline(&buffer, "TEMP temp;\n");
6376 shader_addline(&buffer, "TEMP chroma;\n");
6377 shader_addline(&buffer, "TEMP texcrd;\n");
6378 shader_addline(&buffer, "TEMP texcrd2;\n");
6379 shader_addline(&buffer, "PARAM coef = {1.0, 0.5, 2.0, 0.25};\n");
6380 shader_addline(&buffer, "PARAM yuv_coef = {1.403, 0.344, 0.714, 1.770};\n");
6381 shader_addline(&buffer, "PARAM size = program.local[0];\n");
6385 case YUV_FIXUP_UYVY:
6386 case YUV_FIXUP_YUY2:
6387 if (!gen_planar_yuv_read(&buffer, yuv_fixup, textype, &luminance_component))
6389 shader_buffer_free(&buffer);
6394 case YUV_FIXUP_YV12:
6395 if (!gen_yv12_read(&buffer, textype, &luminance_component))
6397 shader_buffer_free(&buffer);
6403 FIXME("Unsupported YUV fixup %#x\n", yuv_fixup);
6404 shader_buffer_free(&buffer);
6408 /* Calculate the final result. Formula is taken from
6409 * http://www.fourcc.org/fccyvrgb.php. Note that the chroma
6410 * ranges from -0.5 to 0.5
6412 shader_addline(&buffer, "SUB chroma.xy, chroma, coef.y;\n");
6414 shader_addline(&buffer, "MAD result.color.x, chroma.x, yuv_coef.x, luminance.%c;\n", luminance_component);
6415 shader_addline(&buffer, "MAD temp.x, -chroma.y, yuv_coef.y, luminance.%c;\n", luminance_component);
6416 shader_addline(&buffer, "MAD result.color.y, -chroma.x, yuv_coef.z, temp.x;\n");
6417 shader_addline(&buffer, "MAD result.color.z, chroma.y, yuv_coef.w, luminance.%c;\n", luminance_component);
6418 shader_addline(&buffer, "END\n");
6421 GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(buffer.buffer), buffer.buffer));
6423 if (glGetError() == GL_INVALID_OPERATION) {
6425 glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
6426 FIXME("Fragment program error at position %d: %s\n", pos,
6427 debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
6429 shader_buffer_free(&buffer);
6434 case YUV_FIXUP_YUY2:
6435 if (textype == GL_TEXTURE_RECTANGLE_ARB) priv->yuy2_rect_shader = shader;
6436 else priv->yuy2_2d_shader = shader;
6439 case YUV_FIXUP_UYVY:
6440 if (textype == GL_TEXTURE_RECTANGLE_ARB) priv->uyvy_rect_shader = shader;
6441 else priv->uyvy_2d_shader = shader;
6444 case YUV_FIXUP_YV12:
6445 if (textype == GL_TEXTURE_RECTANGLE_ARB) priv->yv12_rect_shader = shader;
6446 else priv->yv12_2d_shader = shader;
6453 /* Context activation is done by the caller. */
6454 static HRESULT arbfp_blit_set(IWineD3DDevice *iface, const struct GlPixelFormatDesc *format_desc,
6455 GLenum textype, UINT width, UINT height)
6458 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) iface;
6459 float size[4] = {width, height, 1, 1};
6460 struct arbfp_blit_priv *priv = device->blit_priv;
6461 enum yuv_fixup yuv_fixup;
6463 if (!is_yuv_fixup(format_desc->color_fixup))
6466 dump_color_fixup_desc(format_desc->color_fixup);
6467 /* Don't bother setting up a shader for unconverted formats */
6470 checkGLcall("glEnable(textype)");
6475 yuv_fixup = get_yuv_fixup(format_desc->color_fixup);
6479 case YUV_FIXUP_YUY2:
6480 shader = textype == GL_TEXTURE_RECTANGLE_ARB ? priv->yuy2_rect_shader : priv->yuy2_2d_shader;
6483 case YUV_FIXUP_UYVY:
6484 shader = textype == GL_TEXTURE_RECTANGLE_ARB ? priv->uyvy_rect_shader : priv->uyvy_2d_shader;
6487 case YUV_FIXUP_YV12:
6488 shader = textype == GL_TEXTURE_RECTANGLE_ARB ? priv->yv12_rect_shader : priv->yv12_2d_shader;
6492 FIXME("Unsupported YUV fixup %#x, not setting a shader\n", yuv_fixup);
6495 checkGLcall("glEnable(textype)");
6500 if (!shader) shader = gen_yuv_shader(device, yuv_fixup, textype);
6503 glEnable(GL_FRAGMENT_PROGRAM_ARB);
6504 checkGLcall("glEnable(GL_FRAGMENT_PROGRAM_ARB)");
6505 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader));
6506 checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader)");
6507 GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 0, size));
6508 checkGLcall("glProgramLocalParameter4fvARB");
6514 /* Context activation is done by the caller. */
6515 static void arbfp_blit_unset(IWineD3DDevice *iface) {
6516 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) iface;
6519 glDisable(GL_FRAGMENT_PROGRAM_ARB);
6520 checkGLcall("glDisable(GL_FRAGMENT_PROGRAM_ARB)");
6521 glDisable(GL_TEXTURE_2D);
6522 checkGLcall("glDisable(GL_TEXTURE_2D)");
6523 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
6524 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
6525 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
6527 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
6528 glDisable(GL_TEXTURE_RECTANGLE_ARB);
6529 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
6534 static BOOL arbfp_blit_color_fixup_supported(struct color_fixup_desc fixup)
6536 enum yuv_fixup yuv_fixup;
6538 if (TRACE_ON(d3d_shader) && TRACE_ON(d3d))
6540 TRACE("Checking support for fixup:\n");
6541 dump_color_fixup_desc(fixup);
6544 if (is_identity_fixup(fixup))
6550 /* We only support YUV conversions. */
6551 if (!is_yuv_fixup(fixup))
6553 TRACE("[FAILED]\n");
6557 yuv_fixup = get_yuv_fixup(fixup);
6560 case YUV_FIXUP_YUY2:
6561 case YUV_FIXUP_UYVY:
6562 case YUV_FIXUP_YV12:
6567 FIXME("Unsupported YUV fixup %#x\n", yuv_fixup);
6568 TRACE("[FAILED]\n");
6573 const struct blit_shader arbfp_blit = {
6578 arbfp_blit_color_fixup_supported,
6581 #undef GLINFO_LOCATION