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 static HRESULT WINAPI
IWineD3DPixelShaderImpl_QueryInterface(IWineD3DPixelShader
*iface
, REFIID riid
, LPVOID
*ppobj
) {
38 TRACE("iface %p, riid %s, ppobj %p\n", iface
, debugstr_guid(riid
), ppobj
);
40 if (IsEqualGUID(riid
, &IID_IWineD3DPixelShader
)
41 || IsEqualGUID(riid
, &IID_IWineD3DBaseShader
)
42 || IsEqualGUID(riid
, &IID_IWineD3DBase
)
43 || IsEqualGUID(riid
, &IID_IUnknown
))
45 IUnknown_AddRef(iface
);
50 WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid
));
56 static ULONG WINAPI
IWineD3DPixelShaderImpl_AddRef(IWineD3DPixelShader
*iface
) {
57 IWineD3DPixelShaderImpl
*This
= (IWineD3DPixelShaderImpl
*)iface
;
58 ULONG refcount
= InterlockedIncrement(&This
->baseShader
.ref
);
60 TRACE("%p increasing refcount to %u\n", This
, refcount
);
65 static ULONG WINAPI
IWineD3DPixelShaderImpl_Release(IWineD3DPixelShader
*iface
) {
66 IWineD3DPixelShaderImpl
*This
= (IWineD3DPixelShaderImpl
*)iface
;
67 ULONG refcount
= InterlockedDecrement(&This
->baseShader
.ref
);
69 TRACE("%p decreasing refcount to %u\n", This
, refcount
);
73 shader_cleanup((IWineD3DBaseShader
*)iface
);
74 HeapFree(GetProcessHeap(), 0, This
);
80 /* *******************************************
81 IWineD3DPixelShader IWineD3DPixelShader parts follow
82 ******************************************* */
84 static HRESULT WINAPI
IWineD3DPixelShaderImpl_GetParent(IWineD3DPixelShader
*iface
, IUnknown
** parent
){
85 IWineD3DPixelShaderImpl
*This
= (IWineD3DPixelShaderImpl
*)iface
;
87 *parent
= This
->parent
;
88 IUnknown_AddRef(*parent
);
89 TRACE("(%p) : returning %p\n", This
, *parent
);
93 static HRESULT WINAPI
IWineD3DPixelShaderImpl_GetDevice(IWineD3DPixelShader
* iface
, IWineD3DDevice
**pDevice
){
94 IWineD3DPixelShaderImpl
*This
= (IWineD3DPixelShaderImpl
*)iface
;
95 IWineD3DDevice_AddRef(This
->baseShader
.device
);
96 *pDevice
= This
->baseShader
.device
;
97 TRACE("(%p) returning %p\n", This
, *pDevice
);
102 static HRESULT WINAPI
IWineD3DPixelShaderImpl_GetFunction(IWineD3DPixelShader
* impl
, VOID
* pData
, UINT
* pSizeOfData
) {
103 IWineD3DPixelShaderImpl
*This
= (IWineD3DPixelShaderImpl
*)impl
;
104 TRACE("(%p) : pData(%p), pSizeOfData(%p)\n", This
, pData
, pSizeOfData
);
107 *pSizeOfData
= This
->baseShader
.functionLength
;
110 if (*pSizeOfData
< This
->baseShader
.functionLength
) {
111 /* MSDN claims (for d3d8 at least) that if *pSizeOfData is smaller
112 * than the required size we should write the required size and
113 * return D3DERR_MOREDATA. That's not actually true. */
114 return WINED3DERR_INVALIDCALL
;
117 TRACE("(%p) : GetFunction copying to %p\n", This
, pData
);
118 memcpy(pData
, This
->baseShader
.function
, This
->baseShader
.functionLength
);
123 const SHADER_OPCODE IWineD3DPixelShaderImpl_shader_ins
[] =
126 {WINED3DSIO_NOP
, 0, 0, WINED3DSIH_NOP
, 0, 0 },
127 {WINED3DSIO_MOV
, 1, 2, WINED3DSIH_MOV
, 0, 0 },
128 {WINED3DSIO_ADD
, 1, 3, WINED3DSIH_ADD
, 0, 0 },
129 {WINED3DSIO_SUB
, 1, 3, WINED3DSIH_SUB
, 0, 0 },
130 {WINED3DSIO_MAD
, 1, 4, WINED3DSIH_MAD
, 0, 0 },
131 {WINED3DSIO_MUL
, 1, 3, WINED3DSIH_MUL
, 0, 0 },
132 {WINED3DSIO_RCP
, 1, 2, WINED3DSIH_RCP
, 0, 0 },
133 {WINED3DSIO_RSQ
, 1, 2, WINED3DSIH_RSQ
, 0, 0 },
134 {WINED3DSIO_DP3
, 1, 3, WINED3DSIH_DP3
, 0, 0 },
135 {WINED3DSIO_DP4
, 1, 3, WINED3DSIH_DP4
, 0, 0 },
136 {WINED3DSIO_MIN
, 1, 3, WINED3DSIH_MIN
, 0, 0 },
137 {WINED3DSIO_MAX
, 1, 3, WINED3DSIH_MAX
, 0, 0 },
138 {WINED3DSIO_SLT
, 1, 3, WINED3DSIH_SLT
, 0, 0 },
139 {WINED3DSIO_SGE
, 1, 3, WINED3DSIH_SGE
, 0, 0 },
140 {WINED3DSIO_ABS
, 1, 2, WINED3DSIH_ABS
, 0, 0 },
141 {WINED3DSIO_EXP
, 1, 2, WINED3DSIH_EXP
, 0, 0 },
142 {WINED3DSIO_LOG
, 1, 2, WINED3DSIH_LOG
, 0, 0 },
143 {WINED3DSIO_EXPP
, 1, 2, WINED3DSIH_EXPP
, 0, 0 },
144 {WINED3DSIO_LOGP
, 1, 2, WINED3DSIH_LOGP
, 0, 0 },
145 {WINED3DSIO_DST
, 1, 3, WINED3DSIH_DST
, 0, 0 },
146 {WINED3DSIO_LRP
, 1, 4, WINED3DSIH_LRP
, 0, 0 },
147 {WINED3DSIO_FRC
, 1, 2, WINED3DSIH_FRC
, 0, 0 },
148 {WINED3DSIO_CND
, 1, 4, WINED3DSIH_CND
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,4)},
149 {WINED3DSIO_CMP
, 1, 4, WINED3DSIH_CMP
, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(3,0)},
150 {WINED3DSIO_POW
, 1, 3, WINED3DSIH_POW
, 0, 0 },
151 {WINED3DSIO_CRS
, 1, 3, WINED3DSIH_CRS
, 0, 0 },
152 {WINED3DSIO_NRM
, 1, 2, WINED3DSIH_NRM
, 0, 0 },
153 {WINED3DSIO_SINCOS
, 1, 4, WINED3DSIH_SINCOS
, WINED3DPS_VERSION(2,0), WINED3DPS_VERSION(2,1)},
154 {WINED3DSIO_SINCOS
, 1, 2, WINED3DSIH_SINCOS
, WINED3DPS_VERSION(3,0), -1 },
155 {WINED3DSIO_DP2ADD
, 1, 4, WINED3DSIH_DP2ADD
, WINED3DPS_VERSION(2,0), -1 },
157 {WINED3DSIO_M4x4
, 1, 3, WINED3DSIH_M4x4
, 0, 0 },
158 {WINED3DSIO_M4x3
, 1, 3, WINED3DSIH_M4x3
, 0, 0 },
159 {WINED3DSIO_M3x4
, 1, 3, WINED3DSIH_M3x4
, 0, 0 },
160 {WINED3DSIO_M3x3
, 1, 3, WINED3DSIH_M3x3
, 0, 0 },
161 {WINED3DSIO_M3x2
, 1, 3, WINED3DSIH_M3x2
, 0, 0 },
162 /* Register declarations */
163 {WINED3DSIO_DCL
, 0, 2, WINED3DSIH_DCL
, 0, 0 },
165 {WINED3DSIO_REP
, 0, 1, WINED3DSIH_REP
, WINED3DPS_VERSION(2,1), -1 },
166 {WINED3DSIO_ENDREP
, 0, 0, WINED3DSIH_ENDREP
, WINED3DPS_VERSION(2,1), -1 },
167 {WINED3DSIO_IF
, 0, 1, WINED3DSIH_IF
, WINED3DPS_VERSION(2,1), -1 },
168 {WINED3DSIO_IFC
, 0, 2, WINED3DSIH_IFC
, WINED3DPS_VERSION(2,1), -1 },
169 {WINED3DSIO_ELSE
, 0, 0, WINED3DSIH_ELSE
, WINED3DPS_VERSION(2,1), -1 },
170 {WINED3DSIO_ENDIF
, 0, 0, WINED3DSIH_ENDIF
, WINED3DPS_VERSION(2,1), -1 },
171 {WINED3DSIO_BREAK
, 0, 0, WINED3DSIH_BREAK
, WINED3DPS_VERSION(2,1), -1 },
172 {WINED3DSIO_BREAKC
, 0, 2, WINED3DSIH_BREAKC
, WINED3DPS_VERSION(2,1), -1 },
173 {WINED3DSIO_BREAKP
, 0, 1, WINED3DSIH_BREAKP
, 0, 0 },
174 {WINED3DSIO_CALL
, 0, 1, WINED3DSIH_CALL
, WINED3DPS_VERSION(2,1), -1 },
175 {WINED3DSIO_CALLNZ
, 0, 2, WINED3DSIH_CALLNZ
, WINED3DPS_VERSION(2,1), -1 },
176 {WINED3DSIO_LOOP
, 0, 2, WINED3DSIH_LOOP
, WINED3DPS_VERSION(3,0), -1 },
177 {WINED3DSIO_RET
, 0, 0, WINED3DSIH_RET
, WINED3DPS_VERSION(2,1), -1 },
178 {WINED3DSIO_ENDLOOP
, 0, 0, WINED3DSIH_ENDLOOP
, WINED3DPS_VERSION(3,0), -1 },
179 {WINED3DSIO_LABEL
, 0, 1, WINED3DSIH_LABEL
, WINED3DPS_VERSION(2,1), -1 },
180 /* Constant definitions */
181 {WINED3DSIO_DEF
, 1, 5, WINED3DSIH_DEF
, 0, 0 },
182 {WINED3DSIO_DEFB
, 1, 2, WINED3DSIH_DEFB
, 0, 0 },
183 {WINED3DSIO_DEFI
, 1, 5, WINED3DSIH_DEFI
, 0, 0 },
185 {WINED3DSIO_TEXCOORD
, 1, 1, WINED3DSIH_TEXCOORD
, 0, WINED3DPS_VERSION(1,3)},
186 {WINED3DSIO_TEXCOORD
, 1, 2, WINED3DSIH_TEXCOORD
, WINED3DPS_VERSION(1,4), WINED3DPS_VERSION(1,4)},
187 {WINED3DSIO_TEXKILL
, 1, 1, WINED3DSIH_TEXKILL
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(3,0)},
188 {WINED3DSIO_TEX
, 1, 1, WINED3DSIH_TEX
, 0, WINED3DPS_VERSION(1,3)},
189 {WINED3DSIO_TEX
, 1, 2, WINED3DSIH_TEX
, WINED3DPS_VERSION(1,4), WINED3DPS_VERSION(1,4)},
190 {WINED3DSIO_TEX
, 1, 3, WINED3DSIH_TEX
, WINED3DPS_VERSION(2,0), -1 },
191 {WINED3DSIO_TEXBEM
, 1, 2, WINED3DSIH_TEXBEM
, 0, WINED3DPS_VERSION(1,3)},
192 {WINED3DSIO_TEXBEML
, 1, 2, WINED3DSIH_TEXBEML
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
193 {WINED3DSIO_TEXREG2AR
, 1, 2, WINED3DSIH_TEXREG2AR
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
194 {WINED3DSIO_TEXREG2GB
, 1, 2, WINED3DSIH_TEXREG2GB
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
195 {WINED3DSIO_TEXREG2RGB
, 1, 2, WINED3DSIH_TEXREG2RGB
, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(1,3)},
196 {WINED3DSIO_TEXM3x2PAD
, 1, 2, WINED3DSIH_TEXM3x2PAD
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
197 {WINED3DSIO_TEXM3x2TEX
, 1, 2, WINED3DSIH_TEXM3x2TEX
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
198 {WINED3DSIO_TEXM3x3PAD
, 1, 2, WINED3DSIH_TEXM3x3PAD
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
199 {WINED3DSIO_TEXM3x3DIFF
, 1, 2, WINED3DSIH_TEXM3x3DIFF
, WINED3DPS_VERSION(0,0), WINED3DPS_VERSION(0,0)},
200 {WINED3DSIO_TEXM3x3SPEC
, 1, 3, WINED3DSIH_TEXM3x3SPEC
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
201 {WINED3DSIO_TEXM3x3VSPEC
, 1, 2, WINED3DSIH_TEXM3x3VSPEC
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
202 {WINED3DSIO_TEXM3x3TEX
, 1, 2, WINED3DSIH_TEXM3x3TEX
, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)},
203 {WINED3DSIO_TEXDP3TEX
, 1, 2, WINED3DSIH_TEXDP3TEX
, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(1,3)},
204 {WINED3DSIO_TEXM3x2DEPTH
, 1, 2, WINED3DSIH_TEXM3x2DEPTH
, WINED3DPS_VERSION(1,3), WINED3DPS_VERSION(1,3)},
205 {WINED3DSIO_TEXDP3
, 1, 2, WINED3DSIH_TEXDP3
, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(1,3)},
206 {WINED3DSIO_TEXM3x3
, 1, 2, WINED3DSIH_TEXM3x3
, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(1,3)},
207 {WINED3DSIO_TEXDEPTH
, 1, 1, WINED3DSIH_TEXDEPTH
, WINED3DPS_VERSION(1,4), WINED3DPS_VERSION(1,4)},
208 {WINED3DSIO_BEM
, 1, 3, WINED3DSIH_BEM
, WINED3DPS_VERSION(1,4), WINED3DPS_VERSION(1,4)},
209 {WINED3DSIO_DSX
, 1, 2, WINED3DSIH_DSX
, WINED3DPS_VERSION(2,1), -1 },
210 {WINED3DSIO_DSY
, 1, 2, WINED3DSIH_DSY
, WINED3DPS_VERSION(2,1), -1 },
211 {WINED3DSIO_TEXLDD
, 1, 5, WINED3DSIH_TEXLDD
, WINED3DPS_VERSION(2,1), -1 },
212 {WINED3DSIO_SETP
, 1, 3, WINED3DSIH_SETP
, 0, 0 },
213 {WINED3DSIO_TEXLDL
, 1, 3, WINED3DSIH_TEXLDL
, WINED3DPS_VERSION(3,0), -1 },
214 {WINED3DSIO_PHASE
, 0, 0, WINED3DSIH_PHASE
, 0, 0 },
215 {0, 0, 0, WINED3DSIH_TABLE_SIZE
, 0, 0 },
218 static void pshader_set_limits(
219 IWineD3DPixelShaderImpl
*This
) {
221 This
->baseShader
.limits
.attributes
= 0;
222 This
->baseShader
.limits
.address
= 0;
223 This
->baseShader
.limits
.packed_output
= 0;
225 switch (This
->baseShader
.reg_maps
.shader_version
)
227 case WINED3DPS_VERSION(1,0):
228 case WINED3DPS_VERSION(1,1):
229 case WINED3DPS_VERSION(1,2):
230 case WINED3DPS_VERSION(1,3):
231 This
->baseShader
.limits
.temporary
= 2;
232 This
->baseShader
.limits
.constant_float
= 8;
233 This
->baseShader
.limits
.constant_int
= 0;
234 This
->baseShader
.limits
.constant_bool
= 0;
235 This
->baseShader
.limits
.texcoord
= 4;
236 This
->baseShader
.limits
.sampler
= 4;
237 This
->baseShader
.limits
.packed_input
= 0;
238 This
->baseShader
.limits
.label
= 0;
241 case WINED3DPS_VERSION(1,4):
242 This
->baseShader
.limits
.temporary
= 6;
243 This
->baseShader
.limits
.constant_float
= 8;
244 This
->baseShader
.limits
.constant_int
= 0;
245 This
->baseShader
.limits
.constant_bool
= 0;
246 This
->baseShader
.limits
.texcoord
= 6;
247 This
->baseShader
.limits
.sampler
= 6;
248 This
->baseShader
.limits
.packed_input
= 0;
249 This
->baseShader
.limits
.label
= 0;
252 /* FIXME: temporaries must match D3DPSHADERCAPS2_0.NumTemps */
253 case WINED3DPS_VERSION(2,0):
254 This
->baseShader
.limits
.temporary
= 32;
255 This
->baseShader
.limits
.constant_float
= 32;
256 This
->baseShader
.limits
.constant_int
= 16;
257 This
->baseShader
.limits
.constant_bool
= 16;
258 This
->baseShader
.limits
.texcoord
= 8;
259 This
->baseShader
.limits
.sampler
= 16;
260 This
->baseShader
.limits
.packed_input
= 0;
263 case WINED3DPS_VERSION(2,1):
264 This
->baseShader
.limits
.temporary
= 32;
265 This
->baseShader
.limits
.constant_float
= 32;
266 This
->baseShader
.limits
.constant_int
= 16;
267 This
->baseShader
.limits
.constant_bool
= 16;
268 This
->baseShader
.limits
.texcoord
= 8;
269 This
->baseShader
.limits
.sampler
= 16;
270 This
->baseShader
.limits
.packed_input
= 0;
271 This
->baseShader
.limits
.label
= 16;
274 case WINED3DPS_VERSION(3,0):
275 This
->baseShader
.limits
.temporary
= 32;
276 This
->baseShader
.limits
.constant_float
= 224;
277 This
->baseShader
.limits
.constant_int
= 16;
278 This
->baseShader
.limits
.constant_bool
= 16;
279 This
->baseShader
.limits
.texcoord
= 0;
280 This
->baseShader
.limits
.sampler
= 16;
281 This
->baseShader
.limits
.packed_input
= 12;
282 This
->baseShader
.limits
.label
= 16; /* FIXME: 2048 */
285 default: This
->baseShader
.limits
.temporary
= 32;
286 This
->baseShader
.limits
.constant_float
= 32;
287 This
->baseShader
.limits
.constant_int
= 16;
288 This
->baseShader
.limits
.constant_bool
= 16;
289 This
->baseShader
.limits
.texcoord
= 8;
290 This
->baseShader
.limits
.sampler
= 16;
291 This
->baseShader
.limits
.packed_input
= 0;
292 This
->baseShader
.limits
.label
= 0;
293 FIXME("Unrecognized pixel shader version %#x\n",
294 This
->baseShader
.reg_maps
.shader_version
);
298 static HRESULT WINAPI
IWineD3DPixelShaderImpl_SetFunction(IWineD3DPixelShader
*iface
, CONST DWORD
*pFunction
) {
300 IWineD3DPixelShaderImpl
*This
=(IWineD3DPixelShaderImpl
*)iface
;
301 IWineD3DDeviceImpl
*deviceImpl
= (IWineD3DDeviceImpl
*) This
->baseShader
.device
;
302 unsigned int i
, highest_reg_used
= 0, num_regs_used
= 0;
303 shader_reg_maps
*reg_maps
= &This
->baseShader
.reg_maps
;
304 const struct wined3d_shader_frontend
*fe
;
307 TRACE("(%p) : pFunction %p\n", iface
, pFunction
);
309 fe
= shader_select_frontend(*pFunction
);
312 FIXME("Unable to find frontend for shader.\n");
313 return WINED3DERR_INVALIDCALL
;
316 /* First pass: trace shader */
317 if (TRACE_ON(d3d_shader
)) shader_trace_init(fe
, pFunction
, This
->baseShader
.shader_ins
);
319 /* Initialize immediate constant lists */
320 list_init(&This
->baseShader
.constantsF
);
321 list_init(&This
->baseShader
.constantsB
);
322 list_init(&This
->baseShader
.constantsI
);
324 /* Second pass: figure out which registers are used, what the semantics are, etc.. */
325 hr
= shader_get_registers_used((IWineD3DBaseShader
*)This
, fe
, reg_maps
, This
->semantics_in
, NULL
, pFunction
);
326 if (FAILED(hr
)) return hr
;
328 pshader_set_limits(This
);
330 for (i
= 0; i
< MAX_REG_INPUT
; ++i
)
332 if (This
->input_reg_used
[i
])
335 highest_reg_used
= i
;
339 /* Don't do any register mapping magic if it is not needed, or if we can't
340 * achieve anything anyway */
341 if (highest_reg_used
< (GL_LIMITS(glsl_varyings
) / 4)
342 || num_regs_used
> (GL_LIMITS(glsl_varyings
) / 4))
344 if (num_regs_used
> (GL_LIMITS(glsl_varyings
) / 4))
346 /* This happens with relative addressing. The input mapper function
347 * warns about this if the higher registers are declared too, so
348 * don't write a FIXME here */
349 WARN("More varying registers used than supported\n");
352 for (i
= 0; i
< MAX_REG_INPUT
; ++i
)
354 This
->input_reg_map
[i
] = i
;
357 This
->declared_in_count
= highest_reg_used
+ 1;
361 This
->declared_in_count
= 0;
362 for (i
= 0; i
< MAX_REG_INPUT
; ++i
)
364 if (This
->input_reg_used
[i
]) This
->input_reg_map
[i
] = This
->declared_in_count
++;
365 else This
->input_reg_map
[i
] = ~0U;
369 This
->baseShader
.load_local_constsF
= FALSE
;
371 This
->baseShader
.shader_mode
= deviceImpl
->ps_selected_mode
;
373 TRACE("(%p) : Copying the function\n", This
);
375 This
->baseShader
.function
= HeapAlloc(GetProcessHeap(), 0, This
->baseShader
.functionLength
);
376 if (!This
->baseShader
.function
) return E_OUTOFMEMORY
;
377 memcpy(This
->baseShader
.function
, pFunction
, This
->baseShader
.functionLength
);
382 static void pixelshader_update_samplers(struct shader_reg_maps
*reg_maps
, IWineD3DBaseTexture
* const *textures
)
384 DWORD shader_version
= reg_maps
->shader_version
;
385 WINED3DSAMPLER_TEXTURE_TYPE
*sampler_type
= reg_maps
->sampler_type
;
388 if (WINED3DSHADER_VERSION_MAJOR(shader_version
) != 1) return;
390 for (i
= 0; i
< max(MAX_FRAGMENT_SAMPLERS
, MAX_VERTEX_SAMPLERS
); ++i
)
392 /* We don't sample from this sampler */
393 if (!sampler_type
[i
]) continue;
397 ERR("No texture bound to sampler %u, using 2D\n", i
);
398 sampler_type
[i
] = WINED3DSTT_2D
;
402 switch (IWineD3DBaseTexture_GetTextureDimensions(textures
[i
]))
404 case GL_TEXTURE_RECTANGLE_ARB
:
406 /* We have to select between texture rectangles and 2D textures later because 2.0 and
407 * 3.0 shaders only have WINED3DSTT_2D as well */
408 sampler_type
[i
] = WINED3DSTT_2D
;
412 sampler_type
[i
] = WINED3DSTT_VOLUME
;
415 case GL_TEXTURE_CUBE_MAP_ARB
:
416 sampler_type
[i
] = WINED3DSTT_CUBE
;
420 FIXME("Unrecognized texture type %#x, using 2D\n",
421 IWineD3DBaseTexture_GetTextureDimensions(textures
[i
]));
422 sampler_type
[i
] = WINED3DSTT_2D
;
427 static GLuint
pixelshader_compile(IWineD3DPixelShaderImpl
*This
, const struct ps_compile_args
*args
)
429 CONST DWORD
*function
= This
->baseShader
.function
;
431 SHADER_BUFFER buffer
;
432 const struct wined3d_shader_frontend
*fe
;
433 IWineD3DDeviceImpl
*device
= (IWineD3DDeviceImpl
*) This
->baseShader
.device
;
435 TRACE("(%p) : function %p\n", This
, function
);
437 fe
= shader_select_frontend(This
->baseShader
.reg_maps
.shader_version
);
440 FIXME("Unable to find frontend for shader.\n");
441 return WINED3DERR_INVALIDCALL
;
444 pixelshader_update_samplers(&This
->baseShader
.reg_maps
,
445 ((IWineD3DDeviceImpl
*)This
->baseShader
.device
)->stateBlock
->textures
);
447 /* Generate the HW shader */
448 TRACE("(%p) : Generating hardware program\n", This
);
449 This
->cur_args
= args
;
450 shader_buffer_init(&buffer
);
451 retval
= device
->shader_backend
->shader_generate_pshader((IWineD3DPixelShader
*)This
, fe
, &buffer
, args
);
452 shader_buffer_free(&buffer
);
453 This
->cur_args
= NULL
;
458 const IWineD3DPixelShaderVtbl IWineD3DPixelShader_Vtbl
=
460 /*** IUnknown methods ***/
461 IWineD3DPixelShaderImpl_QueryInterface
,
462 IWineD3DPixelShaderImpl_AddRef
,
463 IWineD3DPixelShaderImpl_Release
,
464 /*** IWineD3DBase methods ***/
465 IWineD3DPixelShaderImpl_GetParent
,
466 /*** IWineD3DBaseShader methods ***/
467 IWineD3DPixelShaderImpl_SetFunction
,
468 /*** IWineD3DPixelShader methods ***/
469 IWineD3DPixelShaderImpl_GetDevice
,
470 IWineD3DPixelShaderImpl_GetFunction
473 void find_ps_compile_args(IWineD3DPixelShaderImpl
*shader
, IWineD3DStateBlockImpl
*stateblock
, struct ps_compile_args
*args
) {
475 IWineD3DBaseTextureImpl
*tex
;
477 memset(args
, 0, sizeof(*args
)); /* FIXME: Make sure all bits are set */
478 args
->srgb_correction
= stateblock
->renderState
[WINED3DRS_SRGBWRITEENABLE
] ? 1 : 0;
481 for(i
= 0; i
< MAX_FRAGMENT_SAMPLERS
; i
++) {
482 if (!shader
->baseShader
.reg_maps
.sampler_type
[i
]) continue;
483 tex
= (IWineD3DBaseTextureImpl
*) stateblock
->textures
[i
];
485 args
->color_fixup
[i
] = COLOR_FIXUP_IDENTITY
;
488 args
->color_fixup
[i
] = tex
->resource
.format_desc
->color_fixup
;
490 /* Flag samplers that need NP2 texcoord fixup. */
491 if(!tex
->baseTexture
.pow2Matrix_identity
) {
492 args
->np2_fixup
|= (1 << i
);
495 if (shader
->baseShader
.reg_maps
.shader_version
>= WINED3DPS_VERSION(3,0))
497 if (((IWineD3DDeviceImpl
*)shader
->baseShader
.device
)->strided_streams
.position_transformed
)
499 args
->vp_mode
= pretransformed
;
501 else if (use_vs(stateblock
))
503 args
->vp_mode
= vertexshader
;
505 args
->vp_mode
= fixedfunction
;
509 args
->vp_mode
= vertexshader
;
510 if(stateblock
->renderState
[WINED3DRS_FOGENABLE
]) {
511 switch(stateblock
->renderState
[WINED3DRS_FOGTABLEMODE
]) {
512 case WINED3DFOG_NONE
:
513 if (((IWineD3DDeviceImpl
*)shader
->baseShader
.device
)->strided_streams
.position_transformed
514 || use_vs(stateblock
))
516 args
->fog
= FOG_LINEAR
;
519 switch(stateblock
->renderState
[WINED3DRS_FOGVERTEXMODE
]) {
520 case WINED3DFOG_NONE
: /* Drop through */
521 case WINED3DFOG_LINEAR
: args
->fog
= FOG_LINEAR
; break;
522 case WINED3DFOG_EXP
: args
->fog
= FOG_EXP
; break;
523 case WINED3DFOG_EXP2
: args
->fog
= FOG_EXP2
; break;
527 case WINED3DFOG_LINEAR
: args
->fog
= FOG_LINEAR
; break;
528 case WINED3DFOG_EXP
: args
->fog
= FOG_EXP
; break;
529 case WINED3DFOG_EXP2
: args
->fog
= FOG_EXP2
; break;
537 GLuint
find_gl_pshader(IWineD3DPixelShaderImpl
*shader
, const struct ps_compile_args
*args
)
541 struct ps_compiled_shader
*new_array
;
543 /* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
544 * so a linear search is more performant than a hashmap or a binary search
545 * (cache coherency etc)
547 for(i
= 0; i
< shader
->num_gl_shaders
; i
++) {
548 if(memcmp(&shader
->gl_shaders
[i
].args
, args
, sizeof(*args
)) == 0) {
549 return shader
->gl_shaders
[i
].prgId
;
553 TRACE("No matching GL shader found, compiling a new shader\n");
554 if(shader
->shader_array_size
== shader
->num_gl_shaders
) {
555 if (shader
->num_gl_shaders
)
557 new_size
= shader
->shader_array_size
+ max(1, shader
->shader_array_size
/ 2);
558 new_array
= HeapReAlloc(GetProcessHeap(), 0, shader
->gl_shaders
,
559 new_size
* sizeof(*shader
->gl_shaders
));
561 new_array
= HeapAlloc(GetProcessHeap(), 0, sizeof(*shader
->gl_shaders
));
566 ERR("Out of memory\n");
569 shader
->gl_shaders
= new_array
;
570 shader
->shader_array_size
= new_size
;
573 shader
->gl_shaders
[shader
->num_gl_shaders
].args
= *args
;
574 shader
->gl_shaders
[shader
->num_gl_shaders
].prgId
= pixelshader_compile(shader
, args
);
575 return shader
->gl_shaders
[shader
->num_gl_shaders
++].prgId
;