2 * shaders implementation
4 * Copyright 2002-2003 Jason Edmeades
5 * Copyright 2002-2003 Raphael Junqueira
6 * Copyright 2004 Christian Costa
7 * Copyright 2005 Oliver Stieber
8 * Copyright 2006 Ivan Gyurdiev
9 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
31 #include "wined3d_private.h"
33 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader
);
35 #define GLINFO_LOCATION ((IWineD3DDeviceImpl *) This->baseShader.device)->adapter->gl_info
37 #define GLNAME_REQUIRE_GLSL ((const char *)1)
39 static HRESULT WINAPI
IWineD3DPixelShaderImpl_QueryInterface(IWineD3DPixelShader
*iface
, REFIID riid
, LPVOID
*ppobj
) {
40 return IWineD3DBaseShaderImpl_QueryInterface((IWineD3DBaseShader
*) iface
, riid
, ppobj
);
43 static ULONG WINAPI
IWineD3DPixelShaderImpl_AddRef(IWineD3DPixelShader
*iface
) {
44 return IWineD3DBaseShaderImpl_AddRef((IWineD3DBaseShader
*) iface
);
47 static ULONG WINAPI
IWineD3DPixelShaderImpl_Release(IWineD3DPixelShader
*iface
) {
48 return IWineD3DBaseShaderImpl_Release((IWineD3DBaseShader
*) iface
);
51 /* *******************************************
52 IWineD3DPixelShader IWineD3DPixelShader parts follow
53 ******************************************* */
55 static HRESULT WINAPI
IWineD3DPixelShaderImpl_GetParent(IWineD3DPixelShader
*iface
, IUnknown
** parent
){
56 IWineD3DPixelShaderImpl
*This
= (IWineD3DPixelShaderImpl
*)iface
;
58 *parent
= This
->parent
;
59 IUnknown_AddRef(*parent
);
60 TRACE("(%p) : returning %p\n", This
, *parent
);
64 static HRESULT WINAPI
IWineD3DPixelShaderImpl_GetDevice(IWineD3DPixelShader
* iface
, IWineD3DDevice
**pDevice
){
65 IWineD3DPixelShaderImpl
*This
= (IWineD3DPixelShaderImpl
*)iface
;
66 IWineD3DDevice_AddRef(This
->baseShader
.device
);
67 *pDevice
= This
->baseShader
.device
;
68 TRACE("(%p) returning %p\n", This
, *pDevice
);
73 static HRESULT WINAPI
IWineD3DPixelShaderImpl_GetFunction(IWineD3DPixelShader
* impl
, VOID
* pData
, UINT
* pSizeOfData
) {
74 IWineD3DPixelShaderImpl
*This
= (IWineD3DPixelShaderImpl
*)impl
;
75 TRACE("(%p) : pData(%p), pSizeOfData(%p)\n", This
, pData
, pSizeOfData
);
78 *pSizeOfData
= This
->baseShader
.functionLength
;
81 if (*pSizeOfData
< This
->baseShader
.functionLength
) {
82 /* MSDN claims (for d3d8 at least) that if *pSizeOfData is smaller
83 * than the required size we should write the required size and
84 * return D3DERR_MOREDATA. That's not actually true. */
85 return WINED3DERR_INVALIDCALL
;
87 if (NULL
== This
->baseShader
.function
) { /* no function defined */
88 TRACE("(%p) : GetFunction no User Function defined using NULL to %p\n", This
, pData
);
89 (*(DWORD
**) pData
) = NULL
;
91 if (This
->baseShader
.functionLength
== 0) {
94 TRACE("(%p) : GetFunction copying to %p\n", This
, pData
);
95 memcpy(pData
, This
->baseShader
.function
, This
->baseShader
.functionLength
);
100 CONST SHADER_OPCODE IWineD3DPixelShaderImpl_shader_ins
[] = {
102 {WINED3DSIO_NOP
, "nop", "NOP", 0, 0, WINED3DSIH_NOP
, 0, 0 },
103 {WINED3DSIO_MOV
, "mov", "MOV", 1, 2, WINED3DSIH_MOV
, 0, 0 },
104 {WINED3DSIO_ADD
, "add", "ADD", 1, 3, WINED3DSIH_ADD
, 0, 0 },
105 {WINED3DSIO_SUB
, "sub", "SUB", 1, 3, WINED3DSIH_SUB
, 0, 0 },
106 {WINED3DSIO_MAD
, "mad", "MAD", 1, 4, WINED3DSIH_MAD
, 0, 0 },
107 {WINED3DSIO_MUL
, "mul", "MUL", 1, 3, WINED3DSIH_MUL
, 0, 0 },
108 {WINED3DSIO_RCP
, "rcp", "RCP", 1, 2, WINED3DSIH_RCP
, 0, 0 },
109 {WINED3DSIO_RSQ
, "rsq", "RSQ", 1, 2, WINED3DSIH_RSQ
, 0, 0 },
110 {WINED3DSIO_DP3
, "dp3", "DP3", 1, 3, WINED3DSIH_DP3
, 0, 0 },
111 {WINED3DSIO_DP4
, "dp4", "DP4", 1, 3, WINED3DSIH_DP4
, 0, 0 },
112 {WINED3DSIO_MIN
, "min", "MIN", 1, 3, WINED3DSIH_MIN
, 0, 0 },
113 {WINED3DSIO_MAX
, "max", "MAX", 1, 3, WINED3DSIH_MAX
, 0, 0 },
114 {WINED3DSIO_SLT
, "slt", "SLT", 1, 3, WINED3DSIH_SLT
, 0, 0 },
115 {WINED3DSIO_SGE
, "sge", "SGE", 1, 3, WINED3DSIH_SGE
, 0, 0 },
116 {WINED3DSIO_ABS
, "abs", "ABS", 1, 2, WINED3DSIH_ABS
, 0, 0 },
117 {WINED3DSIO_EXP
, "exp", "EX2", 1, 2, WINED3DSIH_EXP
, 0, 0 },
118 {WINED3DSIO_LOG
, "log", "LG2", 1, 2, WINED3DSIH_LOG
, 0, 0 },
119 {WINED3DSIO_EXPP
, "expp", "EXP", 1, 2, WINED3DSIH_EXPP
, 0, 0 },
120 {WINED3DSIO_LOGP
, "logp", "LOG", 1, 2, WINED3DSIH_LOGP
, 0, 0 },
121 {WINED3DSIO_DST
, "dst", "DST", 1, 3, WINED3DSIH_DST
, 0, 0 },
122 {WINED3DSIO_LRP
, "lrp", "LRP", 1, 4, WINED3DSIH_LRP
, 0, 0 },
123 {WINED3DSIO_FRC
, "frc", "FRC", 1, 2, WINED3DSIH_FRC
, 0, 0 },
124 {WINED3DSIO_CND
, "cnd", NULL
, 1, 4, WINED3DSIH_CND
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,4)},
125 {WINED3DSIO_CMP
, "cmp", NULL
, 1, 4, WINED3DSIH_CMP
, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(3,0)},
126 {WINED3DSIO_POW
, "pow", "POW", 1, 3, WINED3DSIH_POW
, 0, 0 },
127 {WINED3DSIO_CRS
, "crs", "XPD", 1, 3, WINED3DSIH_CRS
, 0, 0 },
128 {WINED3DSIO_NRM
, "nrm", NULL
, 1, 2, WINED3DSIH_NRM
, 0, 0 },
129 {WINED3DSIO_SINCOS
, "sincos", NULL
, 1, 4, WINED3DSIH_SINCOS
, WINED3DPS_VERSION(2,0), WINED3DPS_VERSION(2,1)},
130 {WINED3DSIO_SINCOS
, "sincos", "SCS", 1, 2, WINED3DSIH_SINCOS
, WINED3DPS_VERSION(3,0), -1 },
131 {WINED3DSIO_DP2ADD
, "dp2add", NULL
, 1, 4, WINED3DSIH_DP2ADD
, WINED3DPS_VERSION(2,0), -1 },
133 {WINED3DSIO_M4x4
, "m4x4", "undefined", 1, 3, WINED3DSIH_M4x4
, 0, 0 },
134 {WINED3DSIO_M4x3
, "m4x3", "undefined", 1, 3, WINED3DSIH_M4x3
, 0, 0 },
135 {WINED3DSIO_M3x4
, "m3x4", "undefined", 1, 3, WINED3DSIH_M3x4
, 0, 0 },
136 {WINED3DSIO_M3x3
, "m3x3", "undefined", 1, 3, WINED3DSIH_M3x3
, 0, 0 },
137 {WINED3DSIO_M3x2
, "m3x2", "undefined", 1, 3, WINED3DSIH_M3x2
, 0, 0 },
138 /* Register declarations */
139 {WINED3DSIO_DCL
, "dcl", NULL
, 0, 2, WINED3DSIH_DCL
, 0, 0 },
140 /* Flow control - requires GLSL or software shaders */
141 {WINED3DSIO_REP
, "rep", NULL
, 0, 1, WINED3DSIH_REP
, WINED3DPS_VERSION(2,1), -1 },
142 {WINED3DSIO_ENDREP
, "endrep", NULL
, 0, 0, WINED3DSIH_ENDREP
, WINED3DPS_VERSION(2,1), -1 },
143 {WINED3DSIO_IF
, "if", NULL
, 0, 1, WINED3DSIH_IF
, WINED3DPS_VERSION(2,1), -1 },
144 {WINED3DSIO_IFC
, "ifc", NULL
, 0, 2, WINED3DSIH_IFC
, WINED3DPS_VERSION(2,1), -1 },
145 {WINED3DSIO_ELSE
, "else", NULL
, 0, 0, WINED3DSIH_ELSE
, WINED3DPS_VERSION(2,1), -1 },
146 {WINED3DSIO_ENDIF
, "endif", NULL
, 0, 0, WINED3DSIH_ENDIF
, WINED3DPS_VERSION(2,1), -1 },
147 {WINED3DSIO_BREAK
, "break", NULL
, 0, 0, WINED3DSIH_BREAK
, WINED3DPS_VERSION(2,1), -1 },
148 {WINED3DSIO_BREAKC
, "breakc", NULL
, 0, 2, WINED3DSIH_BREAKC
, WINED3DPS_VERSION(2,1), -1 },
149 {WINED3DSIO_BREAKP
, "breakp", GLNAME_REQUIRE_GLSL
, 0, 1, WINED3DSIH_BREAKP
, 0, 0 },
150 {WINED3DSIO_CALL
, "call", NULL
, 0, 1, WINED3DSIH_CALL
, WINED3DPS_VERSION(2,1), -1 },
151 {WINED3DSIO_CALLNZ
, "callnz", NULL
, 0, 2, WINED3DSIH_CALLNZ
, WINED3DPS_VERSION(2,1), -1 },
152 {WINED3DSIO_LOOP
, "loop", NULL
, 0, 2, WINED3DSIH_LOOP
, WINED3DPS_VERSION(3,0), -1 },
153 {WINED3DSIO_RET
, "ret", NULL
, 0, 0, WINED3DSIH_RET
, WINED3DPS_VERSION(2,1), -1 },
154 {WINED3DSIO_ENDLOOP
, "endloop", NULL
, 0, 0, WINED3DSIH_ENDLOOP
, WINED3DPS_VERSION(3,0), -1 },
155 {WINED3DSIO_LABEL
, "label", NULL
, 0, 1, WINED3DSIH_LABEL
, WINED3DPS_VERSION(2,1), -1 },
156 /* Constant definitions */
157 {WINED3DSIO_DEF
, "def", "undefined", 1, 5, WINED3DSIH_DEF
, 0, 0 },
158 {WINED3DSIO_DEFB
, "defb", GLNAME_REQUIRE_GLSL
, 1, 2, WINED3DSIH_DEFB
, 0, 0 },
159 {WINED3DSIO_DEFI
, "defi", GLNAME_REQUIRE_GLSL
, 1, 5, WINED3DSIH_DEFI
, 0, 0 },
161 {WINED3DSIO_TEXCOORD
, "texcoord", "undefined", 1, 1, WINED3DSIH_TEXCOORD
, 0, WINED3DPS_VERSION(1,3)},
162 {WINED3DSIO_TEXCOORD
, "texcrd", "undefined", 1, 2, WINED3DSIH_TEXCOORD
, WINED3DPS_VERSION(1,4), WINED3DPS_VERSION(1,4)},
163 {WINED3DSIO_TEXKILL
, "texkill", "KIL", 1, 1, WINED3DSIH_TEXKILL
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(3,0)},
164 {WINED3DSIO_TEX
, "tex", "undefined", 1, 1, WINED3DSIH_TEX
, 0, WINED3DPS_VERSION(1,3)},
165 {WINED3DSIO_TEX
, "texld", "undefined", 1, 2, WINED3DSIH_TEX
, WINED3DPS_VERSION(1,4), WINED3DPS_VERSION(1,4)},
166 {WINED3DSIO_TEX
, "texld", "undefined", 1, 3, WINED3DSIH_TEX
, WINED3DPS_VERSION(2,0), -1 },
167 {WINED3DSIO_TEXBEM
, "texbem", "undefined", 1, 2, WINED3DSIH_TEXBEM
, 0, WINED3DPS_VERSION(1,3)},
168 {WINED3DSIO_TEXBEML
, "texbeml", GLNAME_REQUIRE_GLSL
, 1, 2, WINED3DSIH_TEXBEML
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
169 {WINED3DSIO_TEXREG2AR
, "texreg2ar", "undefined", 1, 2, WINED3DSIH_TEXREG2AR
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
170 {WINED3DSIO_TEXREG2GB
, "texreg2gb", "undefined", 1, 2, WINED3DSIH_TEXREG2GB
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
171 {WINED3DSIO_TEXREG2RGB
, "texreg2rgb", "undefined", 1, 2, WINED3DSIH_TEXREG2RGB
, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(1,3)},
172 {WINED3DSIO_TEXM3x2PAD
, "texm3x2pad", "undefined", 1, 2, WINED3DSIH_TEXM3x2PAD
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
173 {WINED3DSIO_TEXM3x2TEX
, "texm3x2tex", "undefined", 1, 2, WINED3DSIH_TEXM3x2TEX
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
174 {WINED3DSIO_TEXM3x3PAD
, "texm3x3pad", "undefined", 1, 2, WINED3DSIH_TEXM3x3PAD
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
175 {WINED3DSIO_TEXM3x3DIFF
, "texm3x3diff", GLNAME_REQUIRE_GLSL
, 1, 2, WINED3DSIH_TEXM3x3DIFF
, WINED3DPS_VERSION(0,0), WINED3DPS_VERSION(0,0)},
176 {WINED3DSIO_TEXM3x3SPEC
, "texm3x3spec", "undefined", 1, 3, WINED3DSIH_TEXM3x3SPEC
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
177 {WINED3DSIO_TEXM3x3VSPEC
, "texm3x3vspec", "undefined", 1, 2, WINED3DSIH_TEXM3x3VSPEC
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
178 {WINED3DSIO_TEXM3x3TEX
, "texm3x3tex", "undefined", 1, 2, WINED3DSIH_TEXM3x3TEX
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
179 {WINED3DSIO_TEXDP3TEX
, "texdp3tex", NULL
, 1, 2, WINED3DSIH_TEXDP3TEX
, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(1,3)},
180 {WINED3DSIO_TEXM3x2DEPTH
, "texm3x2depth", GLNAME_REQUIRE_GLSL
, 1, 2, WINED3DSIH_TEXM3x2DEPTH
, WINED3DPS_VERSION(1,3), WINED3DPS_VERSION(1,3)},
181 {WINED3DSIO_TEXDP3
, "texdp3", NULL
, 1, 2, WINED3DSIH_TEXDP3
, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(1,3)},
182 {WINED3DSIO_TEXM3x3
, "texm3x3", NULL
, 1, 2, WINED3DSIH_TEXM3x3
, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(1,3)},
183 {WINED3DSIO_TEXDEPTH
, "texdepth", NULL
, 1, 1, WINED3DSIH_TEXDEPTH
, WINED3DPS_VERSION(1,4), WINED3DPS_VERSION(1,4)},
184 {WINED3DSIO_BEM
, "bem", "undefined", 1, 3, WINED3DSIH_BEM
, WINED3DPS_VERSION(1,4), WINED3DPS_VERSION(1,4)},
185 {WINED3DSIO_DSX
, "dsx", NULL
, 1, 2, WINED3DSIH_DSX
, WINED3DPS_VERSION(2,1), -1 },
186 {WINED3DSIO_DSY
, "dsy", NULL
, 1, 2, WINED3DSIH_DSY
, WINED3DPS_VERSION(2,1), -1 },
187 {WINED3DSIO_TEXLDD
, "texldd", GLNAME_REQUIRE_GLSL
, 1, 5, WINED3DSIH_TEXLDD
, WINED3DPS_VERSION(2,1), -1 },
188 {WINED3DSIO_SETP
, "setp", GLNAME_REQUIRE_GLSL
, 1, 3, WINED3DSIH_SETP
, 0, 0 },
189 {WINED3DSIO_TEXLDL
, "texldl", NULL
, 1, 3, WINED3DSIH_TEXLDL
, WINED3DPS_VERSION(3,0), -1 },
190 {WINED3DSIO_PHASE
, "phase", GLNAME_REQUIRE_GLSL
, 0, 0, WINED3DSIH_PHASE
, 0, 0 },
191 {0, NULL
, NULL
, 0, 0, 0, 0, 0 }
194 static void pshader_set_limits(
195 IWineD3DPixelShaderImpl
*This
) {
197 This
->baseShader
.limits
.attributes
= 0;
198 This
->baseShader
.limits
.address
= 0;
199 This
->baseShader
.limits
.packed_output
= 0;
201 switch (This
->baseShader
.hex_version
) {
202 case WINED3DPS_VERSION(1,0):
203 case WINED3DPS_VERSION(1,1):
204 case WINED3DPS_VERSION(1,2):
205 case WINED3DPS_VERSION(1,3):
206 This
->baseShader
.limits
.temporary
= 2;
207 This
->baseShader
.limits
.constant_float
= 8;
208 This
->baseShader
.limits
.constant_int
= 0;
209 This
->baseShader
.limits
.constant_bool
= 0;
210 This
->baseShader
.limits
.texcoord
= 4;
211 This
->baseShader
.limits
.sampler
= 4;
212 This
->baseShader
.limits
.packed_input
= 0;
213 This
->baseShader
.limits
.label
= 0;
216 case WINED3DPS_VERSION(1,4):
217 This
->baseShader
.limits
.temporary
= 6;
218 This
->baseShader
.limits
.constant_float
= 8;
219 This
->baseShader
.limits
.constant_int
= 0;
220 This
->baseShader
.limits
.constant_bool
= 0;
221 This
->baseShader
.limits
.texcoord
= 6;
222 This
->baseShader
.limits
.sampler
= 6;
223 This
->baseShader
.limits
.packed_input
= 0;
224 This
->baseShader
.limits
.label
= 0;
227 /* FIXME: temporaries must match D3DPSHADERCAPS2_0.NumTemps */
228 case WINED3DPS_VERSION(2,0):
229 This
->baseShader
.limits
.temporary
= 32;
230 This
->baseShader
.limits
.constant_float
= 32;
231 This
->baseShader
.limits
.constant_int
= 16;
232 This
->baseShader
.limits
.constant_bool
= 16;
233 This
->baseShader
.limits
.texcoord
= 8;
234 This
->baseShader
.limits
.sampler
= 16;
235 This
->baseShader
.limits
.packed_input
= 0;
238 case WINED3DPS_VERSION(2,1):
239 This
->baseShader
.limits
.temporary
= 32;
240 This
->baseShader
.limits
.constant_float
= 32;
241 This
->baseShader
.limits
.constant_int
= 16;
242 This
->baseShader
.limits
.constant_bool
= 16;
243 This
->baseShader
.limits
.texcoord
= 8;
244 This
->baseShader
.limits
.sampler
= 16;
245 This
->baseShader
.limits
.packed_input
= 0;
246 This
->baseShader
.limits
.label
= 16;
249 case WINED3DPS_VERSION(3,0):
250 This
->baseShader
.limits
.temporary
= 32;
251 This
->baseShader
.limits
.constant_float
= 224;
252 This
->baseShader
.limits
.constant_int
= 16;
253 This
->baseShader
.limits
.constant_bool
= 16;
254 This
->baseShader
.limits
.texcoord
= 0;
255 This
->baseShader
.limits
.sampler
= 16;
256 This
->baseShader
.limits
.packed_input
= 12;
257 This
->baseShader
.limits
.label
= 16; /* FIXME: 2048 */
260 default: This
->baseShader
.limits
.temporary
= 32;
261 This
->baseShader
.limits
.constant_float
= 32;
262 This
->baseShader
.limits
.constant_int
= 16;
263 This
->baseShader
.limits
.constant_bool
= 16;
264 This
->baseShader
.limits
.texcoord
= 8;
265 This
->baseShader
.limits
.sampler
= 16;
266 This
->baseShader
.limits
.packed_input
= 0;
267 This
->baseShader
.limits
.label
= 0;
268 FIXME("Unrecognized pixel shader version %#x\n",
269 This
->baseShader
.hex_version
);
273 /** Generate a pixel shader string using either GL_FRAGMENT_PROGRAM_ARB
274 or GLSL and send it to the card */
275 static inline GLuint
IWineD3DPixelShaderImpl_GenerateShader(
276 IWineD3DPixelShaderImpl
*This
) {
277 SHADER_BUFFER buffer
;
280 buffer
.buffer
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, SHADER_PGMSIZE
);
283 buffer
.newline
= TRUE
;
285 shader
= ((IWineD3DDeviceImpl
*)This
->baseShader
.device
)->shader_backend
->shader_generate_pshader((IWineD3DPixelShader
*)This
, &buffer
);
287 HeapFree(GetProcessHeap(), 0, buffer
.buffer
);
292 static HRESULT WINAPI
IWineD3DPixelShaderImpl_SetFunction(IWineD3DPixelShader
*iface
, CONST DWORD
*pFunction
) {
294 IWineD3DPixelShaderImpl
*This
=(IWineD3DPixelShaderImpl
*)iface
;
295 IWineD3DDeviceImpl
*deviceImpl
= (IWineD3DDeviceImpl
*) This
->baseShader
.device
;
297 TRACE("(%p) : pFunction %p\n", iface
, pFunction
);
299 /* First pass: trace shader */
300 shader_trace_init((IWineD3DBaseShader
*) This
, pFunction
);
301 pshader_set_limits(This
);
303 /* Initialize immediate constant lists */
304 list_init(&This
->baseShader
.constantsF
);
305 list_init(&This
->baseShader
.constantsB
);
306 list_init(&This
->baseShader
.constantsI
);
308 if (WINED3DSHADER_VERSION_MAJOR(This
->baseShader
.hex_version
) > 1) {
309 shader_reg_maps
*reg_maps
= &This
->baseShader
.reg_maps
;
311 unsigned int i
, j
, highest_reg_used
= 0, num_regs_used
= 0;
313 /* Second pass: figure out which registers are used, what the semantics are, etc.. */
314 memset(reg_maps
, 0, sizeof(shader_reg_maps
));
315 hr
= shader_get_registers_used((IWineD3DBaseShader
*) This
, reg_maps
,
316 This
->semantics_in
, NULL
, pFunction
, NULL
);
317 if (FAILED(hr
)) return hr
;
318 /* FIXME: validate reg_maps against OpenGL */
320 for(i
= 0; i
< MAX_REG_INPUT
; i
++) {
321 if(This
->input_reg_used
[i
]) {
323 highest_reg_used
= i
;
327 /* Don't do any register mapping magic if it is not needed, or if we can't
328 * achieve anything anyway
330 if(highest_reg_used
< (GL_LIMITS(glsl_varyings
) / 4) ||
331 num_regs_used
> (GL_LIMITS(glsl_varyings
) / 4) ) {
332 if(num_regs_used
> (GL_LIMITS(glsl_varyings
) / 4)) {
333 /* This happens with relative addressing. The input mapper function
334 * warns about this if the higher registers are declared too, so
335 * don't write a FIXME here
337 WARN("More varying registers used than supported\n");
340 for(i
= 0; i
< MAX_REG_INPUT
; i
++) {
341 This
->input_reg_map
[i
] = i
;
343 This
->declared_in_count
= highest_reg_used
+ 1;
346 for(i
= 0; i
< MAX_REG_INPUT
; i
++) {
347 if(This
->input_reg_used
[i
]) {
348 This
->input_reg_map
[i
] = j
;
351 This
->input_reg_map
[i
] = -1;
354 This
->declared_in_count
= j
;
357 This
->baseShader
.load_local_constsF
= FALSE
;
359 This
->baseShader
.shader_mode
= deviceImpl
->ps_selected_mode
;
361 TRACE("(%p) : Copying the function\n", This
);
362 if (NULL
!= pFunction
) {
365 function
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, This
->baseShader
.functionLength
);
366 if (!function
) return E_OUTOFMEMORY
;
367 memcpy(function
, pFunction
, This
->baseShader
.functionLength
);
368 This
->baseShader
.function
= function
;
370 This
->baseShader
.function
= NULL
;
376 static GLuint
pixelshader_compile(IWineD3DPixelShaderImpl
*This
, const struct ps_compile_args
*args
)
378 CONST DWORD
*function
= This
->baseShader
.function
;
382 TRACE("(%p) : function %p\n", This
, function
);
384 hr
= IWineD3DPixelShader_UpdateSamplers((IWineD3DPixelShader
*) This
);
386 ERR("Failed to update sampler information\n");
390 /* Reset fields tracking stateblock values being hardcoded in the shader */
391 This
->baseShader
.num_sampled_samplers
= 0;
393 /* Generate the HW shader */
394 TRACE("(%p) : Generating hardware program\n", This
);
395 retval
= IWineD3DPixelShaderImpl_GenerateShader(This
);
397 This
->baseShader
.is_compiled
= TRUE
;
402 static HRESULT WINAPI
IWineD3DPixelShaderImpl_UpdateSamplers(IWineD3DPixelShader
*iface
) {
403 IWineD3DPixelShaderImpl
*This
=(IWineD3DPixelShaderImpl
*)iface
;
405 if (WINED3DSHADER_VERSION_MAJOR(This
->baseShader
.hex_version
) == 1) {
406 IWineD3DDeviceImpl
*deviceImpl
= (IWineD3DDeviceImpl
*) This
->baseShader
.device
;
407 shader_reg_maps
*reg_maps
= &This
->baseShader
.reg_maps
;
410 /* Second pass: figure out which registers are used, what the semantics are, etc.. */
411 memset(reg_maps
, 0, sizeof(shader_reg_maps
));
412 hr
= shader_get_registers_used((IWineD3DBaseShader
*)This
, reg_maps
,
413 This
->semantics_in
, NULL
, This
->baseShader
.function
, deviceImpl
->stateBlock
);
415 /* FIXME: validate reg_maps against OpenGL */
421 const IWineD3DPixelShaderVtbl IWineD3DPixelShader_Vtbl
=
423 /*** IUnknown methods ***/
424 IWineD3DPixelShaderImpl_QueryInterface
,
425 IWineD3DPixelShaderImpl_AddRef
,
426 IWineD3DPixelShaderImpl_Release
,
427 /*** IWineD3DBase methods ***/
428 IWineD3DPixelShaderImpl_GetParent
,
429 /*** IWineD3DBaseShader methods ***/
430 IWineD3DPixelShaderImpl_SetFunction
,
431 /*** IWineD3DPixelShader methods ***/
432 IWineD3DPixelShaderImpl_UpdateSamplers
,
433 IWineD3DPixelShaderImpl_GetDevice
,
434 IWineD3DPixelShaderImpl_GetFunction
437 void find_ps_compile_args(IWineD3DPixelShaderImpl
*shader
, IWineD3DStateBlockImpl
*stateblock
, struct ps_compile_args
*args
) {
439 IWineD3DBaseTextureImpl
*tex
;
441 args
->srgb_correction
= stateblock
->renderState
[WINED3DRS_SRGBWRITEENABLE
] ? 1 : 0;
443 memset(args
->color_fixup
, 0, sizeof(args
->color_fixup
));
444 for(i
= 0; i
< shader
->baseShader
.num_sampled_samplers
; i
++) {
445 sampler
= shader
->baseShader
.sampled_samplers
[i
];
446 tex
= (IWineD3DBaseTextureImpl
*) stateblock
->textures
[sampler
];
448 args
->color_fixup
[sampler
] = COLOR_FIXUP_IDENTITY
;
451 args
->color_fixup
[sampler
] = tex
->baseTexture
.shader_color_fixup
;
453 if(shader
->baseShader
.hex_version
>= WINED3DPS_VERSION(3,0)) {
454 if(((IWineD3DDeviceImpl
*) shader
->baseShader
.device
)->strided_streams
.u
.s
.position_transformed
) {
455 args
->vp_mode
= pretransformed
;
456 } else if(use_vs((IWineD3DDeviceImpl
*) shader
->baseShader
.device
)) {
457 args
->vp_mode
= vertexshader
;
459 args
->vp_mode
= fixedfunction
;
462 args
->vp_mode
= vertexshader
;
466 GLuint
find_gl_pshader(IWineD3DPixelShaderImpl
*shader
, const struct ps_compile_args
*args
)
469 struct ps_compiled_shader
*old_array
;
471 /* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
472 * so a linear search is more performant than a hashmap
474 for(i
= 0; i
< shader
->num_gl_shaders
; i
++) {
475 if(memcmp(&shader
->gl_shaders
[i
].args
, args
, sizeof(*args
)) == 0) {
476 return shader
->gl_shaders
[i
].prgId
;
480 TRACE("No matching GL shader found, compiling a new shader\n");
481 old_array
= shader
->gl_shaders
;
483 shader
->gl_shaders
= HeapReAlloc(GetProcessHeap(), 0, old_array
,
484 (shader
->num_gl_shaders
+ 1) * sizeof(*shader
->gl_shaders
));
486 shader
->gl_shaders
= HeapAlloc(GetProcessHeap(), 0, sizeof(*shader
->gl_shaders
));
489 if(!shader
->gl_shaders
) {
490 ERR("Out of memory\n");
494 shader
->gl_shaders
[shader
->num_gl_shaders
].args
= *args
;
495 shader
->gl_shaders
[shader
->num_gl_shaders
].prgId
= pixelshader_compile(shader
, args
);
496 return shader
->gl_shaders
[shader
->num_gl_shaders
++].prgId
;