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 TRACE("iface %p, riid %s, ppobj %p\n", iface
, debugstr_guid(riid
), ppobj
);
42 if (IsEqualGUID(riid
, &IID_IWineD3DPixelShader
)
43 || IsEqualGUID(riid
, &IID_IWineD3DBaseShader
)
44 || IsEqualGUID(riid
, &IID_IWineD3DBase
)
45 || IsEqualGUID(riid
, &IID_IUnknown
))
47 IUnknown_AddRef(iface
);
52 WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid
));
58 static ULONG WINAPI
IWineD3DPixelShaderImpl_AddRef(IWineD3DPixelShader
*iface
) {
59 IWineD3DPixelShaderImpl
*This
= (IWineD3DPixelShaderImpl
*)iface
;
60 ULONG refcount
= InterlockedIncrement(&This
->baseShader
.ref
);
62 TRACE("%p increasing refcount to %u\n", This
, refcount
);
67 static ULONG WINAPI
IWineD3DPixelShaderImpl_Release(IWineD3DPixelShader
*iface
) {
68 IWineD3DPixelShaderImpl
*This
= (IWineD3DPixelShaderImpl
*)iface
;
69 ULONG refcount
= InterlockedDecrement(&This
->baseShader
.ref
);
71 TRACE("%p decreasing refcount to %u\n", This
, refcount
);
75 shader_cleanup((IWineD3DBaseShader
*)iface
);
76 HeapFree(GetProcessHeap(), 0, This
);
82 /* *******************************************
83 IWineD3DPixelShader IWineD3DPixelShader parts follow
84 ******************************************* */
86 static HRESULT WINAPI
IWineD3DPixelShaderImpl_GetParent(IWineD3DPixelShader
*iface
, IUnknown
** parent
){
87 IWineD3DPixelShaderImpl
*This
= (IWineD3DPixelShaderImpl
*)iface
;
89 *parent
= This
->parent
;
90 IUnknown_AddRef(*parent
);
91 TRACE("(%p) : returning %p\n", This
, *parent
);
95 static HRESULT WINAPI
IWineD3DPixelShaderImpl_GetDevice(IWineD3DPixelShader
* iface
, IWineD3DDevice
**pDevice
){
96 IWineD3DPixelShaderImpl
*This
= (IWineD3DPixelShaderImpl
*)iface
;
97 IWineD3DDevice_AddRef(This
->baseShader
.device
);
98 *pDevice
= This
->baseShader
.device
;
99 TRACE("(%p) returning %p\n", This
, *pDevice
);
104 static HRESULT WINAPI
IWineD3DPixelShaderImpl_GetFunction(IWineD3DPixelShader
* impl
, VOID
* pData
, UINT
* pSizeOfData
) {
105 IWineD3DPixelShaderImpl
*This
= (IWineD3DPixelShaderImpl
*)impl
;
106 TRACE("(%p) : pData(%p), pSizeOfData(%p)\n", This
, pData
, pSizeOfData
);
109 *pSizeOfData
= This
->baseShader
.functionLength
;
112 if (*pSizeOfData
< This
->baseShader
.functionLength
) {
113 /* MSDN claims (for d3d8 at least) that if *pSizeOfData is smaller
114 * than the required size we should write the required size and
115 * return D3DERR_MOREDATA. That's not actually true. */
116 return WINED3DERR_INVALIDCALL
;
118 if (NULL
== This
->baseShader
.function
) { /* no function defined */
119 TRACE("(%p) : GetFunction no User Function defined using NULL to %p\n", This
, pData
);
120 (*(DWORD
**) pData
) = NULL
;
122 TRACE("(%p) : GetFunction copying to %p\n", This
, pData
);
123 memcpy(pData
, This
->baseShader
.function
, This
->baseShader
.functionLength
);
128 CONST SHADER_OPCODE IWineD3DPixelShaderImpl_shader_ins
[] = {
130 {WINED3DSIO_NOP
, "nop", "NOP", 0, 0, WINED3DSIH_NOP
, 0, 0 },
131 {WINED3DSIO_MOV
, "mov", "MOV", 1, 2, WINED3DSIH_MOV
, 0, 0 },
132 {WINED3DSIO_ADD
, "add", "ADD", 1, 3, WINED3DSIH_ADD
, 0, 0 },
133 {WINED3DSIO_SUB
, "sub", "SUB", 1, 3, WINED3DSIH_SUB
, 0, 0 },
134 {WINED3DSIO_MAD
, "mad", "MAD", 1, 4, WINED3DSIH_MAD
, 0, 0 },
135 {WINED3DSIO_MUL
, "mul", "MUL", 1, 3, WINED3DSIH_MUL
, 0, 0 },
136 {WINED3DSIO_RCP
, "rcp", "RCP", 1, 2, WINED3DSIH_RCP
, 0, 0 },
137 {WINED3DSIO_RSQ
, "rsq", "RSQ", 1, 2, WINED3DSIH_RSQ
, 0, 0 },
138 {WINED3DSIO_DP3
, "dp3", "DP3", 1, 3, WINED3DSIH_DP3
, 0, 0 },
139 {WINED3DSIO_DP4
, "dp4", "DP4", 1, 3, WINED3DSIH_DP4
, 0, 0 },
140 {WINED3DSIO_MIN
, "min", "MIN", 1, 3, WINED3DSIH_MIN
, 0, 0 },
141 {WINED3DSIO_MAX
, "max", "MAX", 1, 3, WINED3DSIH_MAX
, 0, 0 },
142 {WINED3DSIO_SLT
, "slt", "SLT", 1, 3, WINED3DSIH_SLT
, 0, 0 },
143 {WINED3DSIO_SGE
, "sge", "SGE", 1, 3, WINED3DSIH_SGE
, 0, 0 },
144 {WINED3DSIO_ABS
, "abs", "ABS", 1, 2, WINED3DSIH_ABS
, 0, 0 },
145 {WINED3DSIO_EXP
, "exp", "EX2", 1, 2, WINED3DSIH_EXP
, 0, 0 },
146 {WINED3DSIO_LOG
, "log", "LG2", 1, 2, WINED3DSIH_LOG
, 0, 0 },
147 {WINED3DSIO_EXPP
, "expp", "EXP", 1, 2, WINED3DSIH_EXPP
, 0, 0 },
148 {WINED3DSIO_LOGP
, "logp", "LOG", 1, 2, WINED3DSIH_LOGP
, 0, 0 },
149 {WINED3DSIO_DST
, "dst", "DST", 1, 3, WINED3DSIH_DST
, 0, 0 },
150 {WINED3DSIO_LRP
, "lrp", "LRP", 1, 4, WINED3DSIH_LRP
, 0, 0 },
151 {WINED3DSIO_FRC
, "frc", "FRC", 1, 2, WINED3DSIH_FRC
, 0, 0 },
152 {WINED3DSIO_CND
, "cnd", NULL
, 1, 4, WINED3DSIH_CND
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,4)},
153 {WINED3DSIO_CMP
, "cmp", NULL
, 1, 4, WINED3DSIH_CMP
, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(3,0)},
154 {WINED3DSIO_POW
, "pow", "POW", 1, 3, WINED3DSIH_POW
, 0, 0 },
155 {WINED3DSIO_CRS
, "crs", "XPD", 1, 3, WINED3DSIH_CRS
, 0, 0 },
156 {WINED3DSIO_NRM
, "nrm", NULL
, 1, 2, WINED3DSIH_NRM
, 0, 0 },
157 {WINED3DSIO_SINCOS
, "sincos", NULL
, 1, 4, WINED3DSIH_SINCOS
, WINED3DPS_VERSION(2,0), WINED3DPS_VERSION(2,1)},
158 {WINED3DSIO_SINCOS
, "sincos", "SCS", 1, 2, WINED3DSIH_SINCOS
, WINED3DPS_VERSION(3,0), -1 },
159 {WINED3DSIO_DP2ADD
, "dp2add", NULL
, 1, 4, WINED3DSIH_DP2ADD
, WINED3DPS_VERSION(2,0), -1 },
161 {WINED3DSIO_M4x4
, "m4x4", "undefined", 1, 3, WINED3DSIH_M4x4
, 0, 0 },
162 {WINED3DSIO_M4x3
, "m4x3", "undefined", 1, 3, WINED3DSIH_M4x3
, 0, 0 },
163 {WINED3DSIO_M3x4
, "m3x4", "undefined", 1, 3, WINED3DSIH_M3x4
, 0, 0 },
164 {WINED3DSIO_M3x3
, "m3x3", "undefined", 1, 3, WINED3DSIH_M3x3
, 0, 0 },
165 {WINED3DSIO_M3x2
, "m3x2", "undefined", 1, 3, WINED3DSIH_M3x2
, 0, 0 },
166 /* Register declarations */
167 {WINED3DSIO_DCL
, "dcl", NULL
, 0, 2, WINED3DSIH_DCL
, 0, 0 },
168 /* Flow control - requires GLSL or software shaders */
169 {WINED3DSIO_REP
, "rep", NULL
, 0, 1, WINED3DSIH_REP
, WINED3DPS_VERSION(2,1), -1 },
170 {WINED3DSIO_ENDREP
, "endrep", NULL
, 0, 0, WINED3DSIH_ENDREP
, WINED3DPS_VERSION(2,1), -1 },
171 {WINED3DSIO_IF
, "if", NULL
, 0, 1, WINED3DSIH_IF
, WINED3DPS_VERSION(2,1), -1 },
172 {WINED3DSIO_IFC
, "ifc", NULL
, 0, 2, WINED3DSIH_IFC
, WINED3DPS_VERSION(2,1), -1 },
173 {WINED3DSIO_ELSE
, "else", NULL
, 0, 0, WINED3DSIH_ELSE
, WINED3DPS_VERSION(2,1), -1 },
174 {WINED3DSIO_ENDIF
, "endif", NULL
, 0, 0, WINED3DSIH_ENDIF
, WINED3DPS_VERSION(2,1), -1 },
175 {WINED3DSIO_BREAK
, "break", NULL
, 0, 0, WINED3DSIH_BREAK
, WINED3DPS_VERSION(2,1), -1 },
176 {WINED3DSIO_BREAKC
, "breakc", NULL
, 0, 2, WINED3DSIH_BREAKC
, WINED3DPS_VERSION(2,1), -1 },
177 {WINED3DSIO_BREAKP
, "breakp", GLNAME_REQUIRE_GLSL
, 0, 1, WINED3DSIH_BREAKP
, 0, 0 },
178 {WINED3DSIO_CALL
, "call", NULL
, 0, 1, WINED3DSIH_CALL
, WINED3DPS_VERSION(2,1), -1 },
179 {WINED3DSIO_CALLNZ
, "callnz", NULL
, 0, 2, WINED3DSIH_CALLNZ
, WINED3DPS_VERSION(2,1), -1 },
180 {WINED3DSIO_LOOP
, "loop", NULL
, 0, 2, WINED3DSIH_LOOP
, WINED3DPS_VERSION(3,0), -1 },
181 {WINED3DSIO_RET
, "ret", NULL
, 0, 0, WINED3DSIH_RET
, WINED3DPS_VERSION(2,1), -1 },
182 {WINED3DSIO_ENDLOOP
, "endloop", NULL
, 0, 0, WINED3DSIH_ENDLOOP
, WINED3DPS_VERSION(3,0), -1 },
183 {WINED3DSIO_LABEL
, "label", NULL
, 0, 1, WINED3DSIH_LABEL
, WINED3DPS_VERSION(2,1), -1 },
184 /* Constant definitions */
185 {WINED3DSIO_DEF
, "def", "undefined", 1, 5, WINED3DSIH_DEF
, 0, 0 },
186 {WINED3DSIO_DEFB
, "defb", GLNAME_REQUIRE_GLSL
, 1, 2, WINED3DSIH_DEFB
, 0, 0 },
187 {WINED3DSIO_DEFI
, "defi", GLNAME_REQUIRE_GLSL
, 1, 5, WINED3DSIH_DEFI
, 0, 0 },
189 {WINED3DSIO_TEXCOORD
, "texcoord", "undefined", 1, 1, WINED3DSIH_TEXCOORD
, 0, WINED3DPS_VERSION(1,3)},
190 {WINED3DSIO_TEXCOORD
, "texcrd", "undefined", 1, 2, WINED3DSIH_TEXCOORD
, WINED3DPS_VERSION(1,4), WINED3DPS_VERSION(1,4)},
191 {WINED3DSIO_TEXKILL
, "texkill", "KIL", 1, 1, WINED3DSIH_TEXKILL
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(3,0)},
192 {WINED3DSIO_TEX
, "tex", "undefined", 1, 1, WINED3DSIH_TEX
, 0, WINED3DPS_VERSION(1,3)},
193 {WINED3DSIO_TEX
, "texld", "undefined", 1, 2, WINED3DSIH_TEX
, WINED3DPS_VERSION(1,4), WINED3DPS_VERSION(1,4)},
194 {WINED3DSIO_TEX
, "texld", "undefined", 1, 3, WINED3DSIH_TEX
, WINED3DPS_VERSION(2,0), -1 },
195 {WINED3DSIO_TEXBEM
, "texbem", "undefined", 1, 2, WINED3DSIH_TEXBEM
, 0, WINED3DPS_VERSION(1,3)},
196 {WINED3DSIO_TEXBEML
, "texbeml", GLNAME_REQUIRE_GLSL
, 1, 2, WINED3DSIH_TEXBEML
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
197 {WINED3DSIO_TEXREG2AR
, "texreg2ar", "undefined", 1, 2, WINED3DSIH_TEXREG2AR
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
198 {WINED3DSIO_TEXREG2GB
, "texreg2gb", "undefined", 1, 2, WINED3DSIH_TEXREG2GB
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
199 {WINED3DSIO_TEXREG2RGB
, "texreg2rgb", "undefined", 1, 2, WINED3DSIH_TEXREG2RGB
, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(1,3)},
200 {WINED3DSIO_TEXM3x2PAD
, "texm3x2pad", "undefined", 1, 2, WINED3DSIH_TEXM3x2PAD
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
201 {WINED3DSIO_TEXM3x2TEX
, "texm3x2tex", "undefined", 1, 2, WINED3DSIH_TEXM3x2TEX
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
202 {WINED3DSIO_TEXM3x3PAD
, "texm3x3pad", "undefined", 1, 2, WINED3DSIH_TEXM3x3PAD
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
203 {WINED3DSIO_TEXM3x3DIFF
, "texm3x3diff", GLNAME_REQUIRE_GLSL
, 1, 2, WINED3DSIH_TEXM3x3DIFF
, WINED3DPS_VERSION(0,0), WINED3DPS_VERSION(0,0)},
204 {WINED3DSIO_TEXM3x3SPEC
, "texm3x3spec", "undefined", 1, 3, WINED3DSIH_TEXM3x3SPEC
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
205 {WINED3DSIO_TEXM3x3VSPEC
, "texm3x3vspec", "undefined", 1, 2, WINED3DSIH_TEXM3x3VSPEC
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
206 {WINED3DSIO_TEXM3x3TEX
, "texm3x3tex", "undefined", 1, 2, WINED3DSIH_TEXM3x3TEX
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
207 {WINED3DSIO_TEXDP3TEX
, "texdp3tex", NULL
, 1, 2, WINED3DSIH_TEXDP3TEX
, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(1,3)},
208 {WINED3DSIO_TEXM3x2DEPTH
, "texm3x2depth", GLNAME_REQUIRE_GLSL
, 1, 2, WINED3DSIH_TEXM3x2DEPTH
, WINED3DPS_VERSION(1,3), WINED3DPS_VERSION(1,3)},
209 {WINED3DSIO_TEXDP3
, "texdp3", NULL
, 1, 2, WINED3DSIH_TEXDP3
, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(1,3)},
210 {WINED3DSIO_TEXM3x3
, "texm3x3", NULL
, 1, 2, WINED3DSIH_TEXM3x3
, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(1,3)},
211 {WINED3DSIO_TEXDEPTH
, "texdepth", NULL
, 1, 1, WINED3DSIH_TEXDEPTH
, WINED3DPS_VERSION(1,4), WINED3DPS_VERSION(1,4)},
212 {WINED3DSIO_BEM
, "bem", "undefined", 1, 3, WINED3DSIH_BEM
, WINED3DPS_VERSION(1,4), WINED3DPS_VERSION(1,4)},
213 {WINED3DSIO_DSX
, "dsx", NULL
, 1, 2, WINED3DSIH_DSX
, WINED3DPS_VERSION(2,1), -1 },
214 {WINED3DSIO_DSY
, "dsy", NULL
, 1, 2, WINED3DSIH_DSY
, WINED3DPS_VERSION(2,1), -1 },
215 {WINED3DSIO_TEXLDD
, "texldd", GLNAME_REQUIRE_GLSL
, 1, 5, WINED3DSIH_TEXLDD
, WINED3DPS_VERSION(2,1), -1 },
216 {WINED3DSIO_SETP
, "setp", GLNAME_REQUIRE_GLSL
, 1, 3, WINED3DSIH_SETP
, 0, 0 },
217 {WINED3DSIO_TEXLDL
, "texldl", NULL
, 1, 3, WINED3DSIH_TEXLDL
, WINED3DPS_VERSION(3,0), -1 },
218 {WINED3DSIO_PHASE
, "phase", GLNAME_REQUIRE_GLSL
, 0, 0, WINED3DSIH_PHASE
, 0, 0 },
219 {0, NULL
, NULL
, 0, 0, 0, 0, 0 }
222 static void pshader_set_limits(
223 IWineD3DPixelShaderImpl
*This
) {
225 This
->baseShader
.limits
.attributes
= 0;
226 This
->baseShader
.limits
.address
= 0;
227 This
->baseShader
.limits
.packed_output
= 0;
229 switch (This
->baseShader
.hex_version
) {
230 case WINED3DPS_VERSION(1,0):
231 case WINED3DPS_VERSION(1,1):
232 case WINED3DPS_VERSION(1,2):
233 case WINED3DPS_VERSION(1,3):
234 This
->baseShader
.limits
.temporary
= 2;
235 This
->baseShader
.limits
.constant_float
= 8;
236 This
->baseShader
.limits
.constant_int
= 0;
237 This
->baseShader
.limits
.constant_bool
= 0;
238 This
->baseShader
.limits
.texcoord
= 4;
239 This
->baseShader
.limits
.sampler
= 4;
240 This
->baseShader
.limits
.packed_input
= 0;
241 This
->baseShader
.limits
.label
= 0;
244 case WINED3DPS_VERSION(1,4):
245 This
->baseShader
.limits
.temporary
= 6;
246 This
->baseShader
.limits
.constant_float
= 8;
247 This
->baseShader
.limits
.constant_int
= 0;
248 This
->baseShader
.limits
.constant_bool
= 0;
249 This
->baseShader
.limits
.texcoord
= 6;
250 This
->baseShader
.limits
.sampler
= 6;
251 This
->baseShader
.limits
.packed_input
= 0;
252 This
->baseShader
.limits
.label
= 0;
255 /* FIXME: temporaries must match D3DPSHADERCAPS2_0.NumTemps */
256 case WINED3DPS_VERSION(2,0):
257 This
->baseShader
.limits
.temporary
= 32;
258 This
->baseShader
.limits
.constant_float
= 32;
259 This
->baseShader
.limits
.constant_int
= 16;
260 This
->baseShader
.limits
.constant_bool
= 16;
261 This
->baseShader
.limits
.texcoord
= 8;
262 This
->baseShader
.limits
.sampler
= 16;
263 This
->baseShader
.limits
.packed_input
= 0;
266 case WINED3DPS_VERSION(2,1):
267 This
->baseShader
.limits
.temporary
= 32;
268 This
->baseShader
.limits
.constant_float
= 32;
269 This
->baseShader
.limits
.constant_int
= 16;
270 This
->baseShader
.limits
.constant_bool
= 16;
271 This
->baseShader
.limits
.texcoord
= 8;
272 This
->baseShader
.limits
.sampler
= 16;
273 This
->baseShader
.limits
.packed_input
= 0;
274 This
->baseShader
.limits
.label
= 16;
277 case WINED3DPS_VERSION(3,0):
278 This
->baseShader
.limits
.temporary
= 32;
279 This
->baseShader
.limits
.constant_float
= 224;
280 This
->baseShader
.limits
.constant_int
= 16;
281 This
->baseShader
.limits
.constant_bool
= 16;
282 This
->baseShader
.limits
.texcoord
= 0;
283 This
->baseShader
.limits
.sampler
= 16;
284 This
->baseShader
.limits
.packed_input
= 12;
285 This
->baseShader
.limits
.label
= 16; /* FIXME: 2048 */
288 default: This
->baseShader
.limits
.temporary
= 32;
289 This
->baseShader
.limits
.constant_float
= 32;
290 This
->baseShader
.limits
.constant_int
= 16;
291 This
->baseShader
.limits
.constant_bool
= 16;
292 This
->baseShader
.limits
.texcoord
= 8;
293 This
->baseShader
.limits
.sampler
= 16;
294 This
->baseShader
.limits
.packed_input
= 0;
295 This
->baseShader
.limits
.label
= 0;
296 FIXME("Unrecognized pixel shader version %#x\n",
297 This
->baseShader
.hex_version
);
301 /** Generate a pixel shader string using either GL_FRAGMENT_PROGRAM_ARB
302 or GLSL and send it to the card */
303 static inline GLuint
IWineD3DPixelShaderImpl_GenerateShader(
304 IWineD3DPixelShaderImpl
*This
) {
305 SHADER_BUFFER buffer
;
308 shader_buffer_init(&buffer
);
309 shader
= ((IWineD3DDeviceImpl
*)This
->baseShader
.device
)->shader_backend
->shader_generate_pshader((IWineD3DPixelShader
*)This
, &buffer
);
310 shader_buffer_free(&buffer
);
315 static HRESULT WINAPI
IWineD3DPixelShaderImpl_SetFunction(IWineD3DPixelShader
*iface
, CONST DWORD
*pFunction
) {
317 IWineD3DPixelShaderImpl
*This
=(IWineD3DPixelShaderImpl
*)iface
;
318 IWineD3DDeviceImpl
*deviceImpl
= (IWineD3DDeviceImpl
*) This
->baseShader
.device
;
319 unsigned int i
, highest_reg_used
= 0, num_regs_used
= 0;
320 shader_reg_maps
*reg_maps
= &This
->baseShader
.reg_maps
;
323 TRACE("(%p) : pFunction %p\n", iface
, pFunction
);
325 /* First pass: trace shader */
326 if (TRACE_ON(d3d_shader
)) shader_trace_init(pFunction
, This
->baseShader
.shader_ins
);
328 /* Initialize immediate constant lists */
329 list_init(&This
->baseShader
.constantsF
);
330 list_init(&This
->baseShader
.constantsB
);
331 list_init(&This
->baseShader
.constantsI
);
333 /* Second pass: figure out which registers are used, what the semantics are, etc.. */
334 memset(reg_maps
, 0, sizeof(shader_reg_maps
));
335 hr
= shader_get_registers_used((IWineD3DBaseShader
*)This
, reg_maps
, This
->semantics_in
, NULL
, pFunction
);
336 if (FAILED(hr
)) return hr
;
338 pshader_set_limits(This
);
340 for (i
= 0; i
< MAX_REG_INPUT
; ++i
)
342 if (This
->input_reg_used
[i
])
345 highest_reg_used
= i
;
349 /* Don't do any register mapping magic if it is not needed, or if we can't
350 * achieve anything anyway */
351 if (highest_reg_used
< (GL_LIMITS(glsl_varyings
) / 4)
352 || num_regs_used
> (GL_LIMITS(glsl_varyings
) / 4))
354 if (num_regs_used
> (GL_LIMITS(glsl_varyings
) / 4))
356 /* This happens with relative addressing. The input mapper function
357 * warns about this if the higher registers are declared too, so
358 * don't write a FIXME here */
359 WARN("More varying registers used than supported\n");
362 for (i
= 0; i
< MAX_REG_INPUT
; ++i
)
364 This
->input_reg_map
[i
] = i
;
367 This
->declared_in_count
= highest_reg_used
+ 1;
371 This
->declared_in_count
= 0;
372 for (i
= 0; i
< MAX_REG_INPUT
; ++i
)
374 if (This
->input_reg_used
[i
]) This
->input_reg_map
[i
] = This
->declared_in_count
++;
375 else This
->input_reg_map
[i
] = -1;
379 This
->baseShader
.load_local_constsF
= FALSE
;
381 This
->baseShader
.shader_mode
= deviceImpl
->ps_selected_mode
;
383 TRACE("(%p) : Copying the function\n", This
);
384 if (NULL
!= pFunction
) {
387 function
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, This
->baseShader
.functionLength
);
388 if (!function
) return E_OUTOFMEMORY
;
389 memcpy(function
, pFunction
, This
->baseShader
.functionLength
);
390 This
->baseShader
.function
= function
;
392 This
->baseShader
.function
= NULL
;
398 static void pixelshader_update_samplers(struct shader_reg_maps
*reg_maps
, IWineD3DBaseTexture
* const *textures
,
399 DWORD shader_version
)
401 DWORD
*samplers
= reg_maps
->samplers
;
404 if (WINED3DSHADER_VERSION_MAJOR(shader_version
) != 1) return;
406 for (i
= 0; i
< max(MAX_FRAGMENT_SAMPLERS
, MAX_VERTEX_SAMPLERS
); ++i
)
408 /* We don't sample from this sampler */
409 if (!samplers
[i
]) continue;
413 ERR("No texture bound to sampler %u, using 2D\n", i
);
414 samplers
[i
] = (0x1 << 31) | WINED3DSTT_2D
;
418 switch (IWineD3DBaseTexture_GetTextureDimensions(textures
[i
]))
420 case GL_TEXTURE_RECTANGLE_ARB
:
422 /* We have to select between texture rectangles and 2D textures later because 2.0 and
423 * 3.0 shaders only have WINED3DSTT_2D as well */
424 samplers
[i
] = (1 << 31) | WINED3DSTT_2D
;
428 samplers
[i
] = (1 << 31) | WINED3DSTT_VOLUME
;
431 case GL_TEXTURE_CUBE_MAP_ARB
:
432 samplers
[i
] = (1 << 31) | WINED3DSTT_CUBE
;
436 FIXME("Unrecognized texture type %#x, using 2D\n",
437 IWineD3DBaseTexture_GetTextureDimensions(textures
[i
]));
438 samplers
[i
] = (0x1 << 31) | WINED3DSTT_2D
;
443 static GLuint
pixelshader_compile(IWineD3DPixelShaderImpl
*This
, const struct ps_compile_args
*args
)
445 CONST DWORD
*function
= This
->baseShader
.function
;
448 TRACE("(%p) : function %p\n", This
, function
);
450 pixelshader_update_samplers(&This
->baseShader
.reg_maps
,
451 ((IWineD3DDeviceImpl
*)This
->baseShader
.device
)->stateBlock
->textures
, This
->baseShader
.hex_version
);
453 /* Reset fields tracking stateblock values being hardcoded in the shader */
454 This
->baseShader
.num_sampled_samplers
= 0;
456 /* Generate the HW shader */
457 TRACE("(%p) : Generating hardware program\n", This
);
458 retval
= IWineD3DPixelShaderImpl_GenerateShader(This
);
460 This
->baseShader
.is_compiled
= TRUE
;
465 const IWineD3DPixelShaderVtbl IWineD3DPixelShader_Vtbl
=
467 /*** IUnknown methods ***/
468 IWineD3DPixelShaderImpl_QueryInterface
,
469 IWineD3DPixelShaderImpl_AddRef
,
470 IWineD3DPixelShaderImpl_Release
,
471 /*** IWineD3DBase methods ***/
472 IWineD3DPixelShaderImpl_GetParent
,
473 /*** IWineD3DBaseShader methods ***/
474 IWineD3DPixelShaderImpl_SetFunction
,
475 /*** IWineD3DPixelShader methods ***/
476 IWineD3DPixelShaderImpl_GetDevice
,
477 IWineD3DPixelShaderImpl_GetFunction
480 void find_ps_compile_args(IWineD3DPixelShaderImpl
*shader
, IWineD3DStateBlockImpl
*stateblock
, struct ps_compile_args
*args
) {
482 IWineD3DBaseTextureImpl
*tex
;
484 args
->srgb_correction
= stateblock
->renderState
[WINED3DRS_SRGBWRITEENABLE
] ? 1 : 0;
486 memset(args
->color_fixup
, 0, sizeof(args
->color_fixup
));
487 for(i
= 0; i
< shader
->baseShader
.num_sampled_samplers
; i
++) {
488 sampler
= shader
->baseShader
.sampled_samplers
[i
];
489 tex
= (IWineD3DBaseTextureImpl
*) stateblock
->textures
[sampler
];
491 args
->color_fixup
[sampler
] = COLOR_FIXUP_IDENTITY
;
494 args
->color_fixup
[sampler
] = tex
->baseTexture
.shader_color_fixup
;
496 if(shader
->baseShader
.hex_version
>= WINED3DPS_VERSION(3,0)) {
497 if(((IWineD3DDeviceImpl
*) shader
->baseShader
.device
)->strided_streams
.u
.s
.position_transformed
) {
498 args
->vp_mode
= pretransformed
;
499 } else if(use_vs((IWineD3DDeviceImpl
*) shader
->baseShader
.device
)) {
500 args
->vp_mode
= vertexshader
;
502 args
->vp_mode
= fixedfunction
;
505 args
->vp_mode
= vertexshader
;
509 GLuint
find_gl_pshader(IWineD3DPixelShaderImpl
*shader
, const struct ps_compile_args
*args
)
512 struct ps_compiled_shader
*old_array
;
514 /* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
515 * so a linear search is more performant than a hashmap
517 for(i
= 0; i
< shader
->num_gl_shaders
; i
++) {
518 if(memcmp(&shader
->gl_shaders
[i
].args
, args
, sizeof(*args
)) == 0) {
519 return shader
->gl_shaders
[i
].prgId
;
523 TRACE("No matching GL shader found, compiling a new shader\n");
524 old_array
= shader
->gl_shaders
;
526 shader
->gl_shaders
= HeapReAlloc(GetProcessHeap(), 0, old_array
,
527 (shader
->num_gl_shaders
+ 1) * sizeof(*shader
->gl_shaders
));
529 shader
->gl_shaders
= HeapAlloc(GetProcessHeap(), 0, sizeof(*shader
->gl_shaders
));
532 if(!shader
->gl_shaders
) {
533 ERR("Out of memory\n");
537 shader
->gl_shaders
[shader
->num_gl_shaders
].args
= *args
;
538 shader
->gl_shaders
[shader
->num_gl_shaders
].prgId
= pixelshader_compile(shader
, args
);
539 return shader
->gl_shaders
[shader
->num_gl_shaders
++].prgId
;