?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Add D3DSI and other opcode masks to the WINED3D namespace.
[wine/wine64.git] / dlls / wined3d / vertexshader.c
blob9e481072c2baf13a87f68c5fa7660f3bd65eb824
1 /*
2 * shaders implementation
3 *
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 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25 #include "config.h"
26
27 #include <math.h>
28 #include <stdio.h>
29
30 #include "wined3d_private.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
33
34 #define GLINFO_LOCATION ((IWineD3DImpl *)(((IWineD3DDeviceImpl *)This->baseShader.device)->wineD3D))->gl_info
35
36 /* Shader debugging - Change the following line to enable debugging of software
37 vertex shaders */
38 #if 0 /* Musxt not be 1 in cvs version */
39 # define VSTRACE(A) TRACE A
40 # define TRACE_VSVECTOR(name) TRACE( #name "=(%f, %f, %f, %f)\n", name.x, name.y, name.z, name.w)
41 #else
42 # define VSTRACE(A)
43 # define TRACE_VSVECTOR(name)
44 #endif
45
46 /**
47 * DirectX9 SDK download
48 * http://msdn.microsoft.com/library/default.asp?url=/downloads/list/directx.asp
49 *
50 * Exploring D3DX
51 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndrive/html/directx07162002.asp
52 *
53 * Using Vertex Shaders
54 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndrive/html/directx02192001.asp
55 *
56 * Dx9 New
57 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/whatsnew.asp
58 *
59 * Dx9 Shaders
60 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/VertexShader2_0/VertexShader2_0.asp
61 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/VertexShader2_0/Instructions/Instructions.asp
62 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/programmingguide/GettingStarted/VertexDeclaration/VertexDeclaration.asp
63 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/VertexShader3_0/VertexShader3_0.asp
64 *
65 * Dx9 D3DX
66 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/programmingguide/advancedtopics/VertexPipe/matrixstack/matrixstack.asp
67 *
68 * FVF
69 * http://msdn.microsoft.com/library/en-us/directx9_c/directx/graphics/programmingguide/GettingStarted/VertexFormats/vformats.asp
70 *
71 * NVIDIA: DX8 Vertex Shader to NV Vertex Program
72 * http://developer.nvidia.com/view.asp?IO=vstovp
73 *
74 * NVIDIA: Memory Management with VAR
75 * http://developer.nvidia.com/view.asp?IO=var_memory_management
76 */
77
78 /* TODO: Vertex and Pixel shaders are almost identicle, the only exception being the way that some of the data is looked up or the availablity of some of the data i.e. some instructions are only valid for pshaders and some for vshaders
79 because of this the bulk of the software pipeline can be shared between pixel and vertex shaders... and it wouldn't supprise me if the programes can be cross compiled using a large body body shared code */
80
81 #define GLNAME_REQUIRE_GLSL ((const char *)1)
82
83 /*******************************
84 * vshader functions software VM
85 */
86
87 static void vshader_add(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
88 d->x = s0->x + s1->x;
89 d->y = s0->y + s1->y;
90 d->z = s0->z + s1->z;
91 d->w = s0->w + s1->w;
92 VSTRACE(("executing add: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
93 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
94 }
95
96 static void vshader_dp3(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
97 d->x = d->y = d->z = d->w = s0->x * s1->x + s0->y * s1->y + s0->z * s1->z;
98 VSTRACE(("executing dp3: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
99 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
100 }
101
102 static void vshader_dp4(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
103 d->x = d->y = d->z = d->w = s0->x * s1->x + s0->y * s1->y + s0->z * s1->z + s0->w * s1->w;
104 VSTRACE(("executing dp4: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
105 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
106 }
107
108 static void vshader_dst(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
109 d->x = 1.0f;
110 d->y = s0->y * s1->y;
111 d->z = s0->z;
112 d->w = s1->w;
113 VSTRACE(("executing dst: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
114 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
115 }
116
117 static void vshader_expp(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
118 union {
119 float f;
120 DWORD d;
121 } tmp;
122
123 tmp.f = floorf(s0->w);
124 d->x = powf(2.0f, tmp.f);
125 d->y = s0->w - tmp.f;
126 tmp.f = powf(2.0f, s0->w);
127 tmp.d &= 0xFFFFFF00U;
128 d->z = tmp.f;
129 d->w = 1.0f;
130 VSTRACE(("executing exp: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
131 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
132 }
133
134 static void vshader_lit(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
135 d->x = 1.0f;
136 d->y = (0.0f < s0->x) ? s0->x : 0.0f;
137 d->z = (0.0f < s0->x && 0.0f < s0->y) ? powf(s0->y, s0->w) : 0.0f;
138 d->w = 1.0f;
139 VSTRACE(("executing lit: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
140 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
141 }
142
143 static void vshader_logp(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
144 float tmp_f = fabsf(s0->w);
145 d->x = d->y = d->z = d->w = (0.0f != tmp_f) ? logf(tmp_f) / logf(2.0f) : -HUGE_VAL;
146 VSTRACE(("executing logp: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
147 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
148 }
149
150 static void vshader_mad(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1, WINED3DSHADERVECTOR* s2) {
151 d->x = s0->x * s1->x + s2->x;
152 d->y = s0->y * s1->y + s2->y;
153 d->z = s0->z * s1->z + s2->z;
154 d->w = s0->w * s1->w + s2->w;
155 VSTRACE(("executing mad: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) s2=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
156 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, s2->x, s2->y, s2->z, s2->w, d->x, d->y, d->z, d->w));
157 }
158
159 static void vshader_max(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
160 d->x = (s0->x >= s1->x) ? s0->x : s1->x;
161 d->y = (s0->y >= s1->y) ? s0->y : s1->y;
162 d->z = (s0->z >= s1->z) ? s0->z : s1->z;
163 d->w = (s0->w >= s1->w) ? s0->w : s1->w;
164 VSTRACE(("executing max: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
165 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
166 }
167
168 static void vshader_min(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
169 d->x = (s0->x < s1->x) ? s0->x : s1->x;
170 d->y = (s0->y < s1->y) ? s0->y : s1->y;
171 d->z = (s0->z < s1->z) ? s0->z : s1->z;
172 d->w = (s0->w < s1->w) ? s0->w : s1->w;
173 VSTRACE(("executing min: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
174 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
175 }
176
177 static void vshader_mov(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
178 d->x = s0->x;
179 d->y = s0->y;
180 d->z = s0->z;
181 d->w = s0->w;
182 VSTRACE(("executing mov: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
183 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
184 }
185
186 static void vshader_mul(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
187 d->x = s0->x * s1->x;
188 d->y = s0->y * s1->y;
189 d->z = s0->z * s1->z;
190 d->w = s0->w * s1->w;
191 VSTRACE(("executing mul: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
192 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
193 }
194
195 static void vshader_nop(void) {
196 /* NOPPPP ahhh too easy ;) */
197 VSTRACE(("executing nop\n"));
198 }
199
200 static void vshader_rcp(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
201 d->x = d->y = d->z = d->w = (0.0f == s0->w) ? HUGE_VAL : 1.0f / s0->w;
202 VSTRACE(("executing rcp: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
203 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
204 }
205
206 static void vshader_rsq(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
207 float tmp_f = fabsf(s0->w);
208 d->x = d->y = d->z = d->w = (0.0f == tmp_f) ? HUGE_VAL : ((1.0f != tmp_f) ? 1.0f / sqrtf(tmp_f) : 1.0f);
209 VSTRACE(("executing rsq: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
210 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
211 }
212
213 static void vshader_sge(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
214 d->x = (s0->x >= s1->x) ? 1.0f : 0.0f;
215 d->y = (s0->y >= s1->y) ? 1.0f : 0.0f;
216 d->z = (s0->z >= s1->z) ? 1.0f : 0.0f;
217 d->w = (s0->w >= s1->w) ? 1.0f : 0.0f;
218 VSTRACE(("executing sge: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
219 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
220 }
221
222 static void vshader_slt(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
223 d->x = (s0->x < s1->x) ? 1.0f : 0.0f;
224 d->y = (s0->y < s1->y) ? 1.0f : 0.0f;
225 d->z = (s0->z < s1->z) ? 1.0f : 0.0f;
226 d->w = (s0->w < s1->w) ? 1.0f : 0.0f;
227 VSTRACE(("executing slt: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
228 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
229 }
230
231 static void vshader_sub(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
232 d->x = s0->x - s1->x;
233 d->y = s0->y - s1->y;
234 d->z = s0->z - s1->z;
235 d->w = s0->w - s1->w;
236 VSTRACE(("executing sub: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
237 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
238 }
239
240 /**
241 * Version 1.1 specific
242 */
243
244 static void vshader_exp(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
245 d->x = d->y = d->z = d->w = powf(2.0f, s0->w);
246 VSTRACE(("executing exp: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
247 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
248 }
249
250 static void vshader_log(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
251 float tmp_f = fabsf(s0->w);
252 d->x = d->y = d->z = d->w = (0.0f != tmp_f) ? logf(tmp_f) / logf(2.0f) : -HUGE_VAL;
253 VSTRACE(("executing log: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
254 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
255 }
256
257 static void vshader_frc(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
258 d->x = s0->x - floorf(s0->x);
259 d->y = s0->y - floorf(s0->y);
260 d->z = 0.0f;
261 d->w = 1.0f;
262 VSTRACE(("executing frc: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
263 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
264 }
265
266 typedef FLOAT D3DMATRIX44[4][4];
267 typedef FLOAT D3DMATRIX43[4][3];
268 typedef FLOAT D3DMATRIX34[3][4];
269 typedef FLOAT D3DMATRIX33[3][3];
270 typedef FLOAT D3DMATRIX23[2][3];
271
272 static void vshader_m4x4(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, /*WINED3DSHADERVECTOR* mat1*/ D3DMATRIX44 mat) {
273 /*
274 * Buggy CODE: here only if cast not work for copy/paste
275 WINED3DSHADERVECTOR* mat2 = mat1 + 1;
276 WINED3DSHADERVECTOR* mat3 = mat1 + 2;
277 WINED3DSHADERVECTOR* mat4 = mat1 + 3;
278 d->x = mat1->x * s0->x + mat2->x * s0->y + mat3->x * s0->z + mat4->x * s0->w;
279 d->y = mat1->y * s0->x + mat2->y * s0->y + mat3->y * s0->z + mat4->y * s0->w;
280 d->z = mat1->z * s0->x + mat2->z * s0->y + mat3->z * s0->z + mat4->z * s0->w;
281 d->w = mat1->w * s0->x + mat2->w * s0->y + mat3->w * s0->z + mat4->w * s0->w;
282 */
283 d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z + mat[0][3] * s0->w;
284 d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z + mat[1][3] * s0->w;
285 d->z = mat[2][0] * s0->x + mat[2][1] * s0->y + mat[2][2] * s0->z + mat[2][3] * s0->w;
286 d->w = mat[3][0] * s0->x + mat[3][1] * s0->y + mat[3][2] * s0->z + mat[3][3] * s0->w;
287 VSTRACE(("executing m4x4(1): mat=(%f, %f, %f, %f) s0=(%f) d=(%f) \n", mat[0][0], mat[0][1], mat[0][2], mat[0][3], s0->x, d->x));
288 VSTRACE(("executing m4x4(2): mat=(%f, %f, %f, %f) (%f) (%f) \n", mat[1][0], mat[1][1], mat[1][2], mat[1][3], s0->y, d->y));
289 VSTRACE(("executing m4x4(3): mat=(%f, %f, %f, %f) X (%f) = (%f) \n", mat[2][0], mat[2][1], mat[2][2], mat[2][3], s0->z, d->z));
290 VSTRACE(("executing m4x4(4): mat=(%f, %f, %f, %f) (%f) (%f) \n", mat[3][0], mat[3][1], mat[3][2], mat[3][3], s0->w, d->w));
291 }
292
293 static void vshader_m4x3(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, D3DMATRIX34 mat) {
294 d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z + mat[0][3] * s0->w;
295 d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z + mat[1][3] * s0->w;
296 d->z = mat[2][0] * s0->x + mat[2][1] * s0->y + mat[2][2] * s0->z + mat[2][3] * s0->w;
297 d->w = 1.0f;
298 VSTRACE(("executing m4x3(1): mat=(%f, %f, %f, %f) s0=(%f) d=(%f) \n", mat[0][0], mat[0][1], mat[0][2], mat[0][3], s0->x, d->x));
299 VSTRACE(("executing m4x3(2): mat=(%f, %f, %f, %f) (%f) (%f) \n", mat[1][0], mat[1][1], mat[1][2], mat[1][3], s0->y, d->y));
300 VSTRACE(("executing m4x3(3): mat=(%f, %f, %f, %f) X (%f) = (%f) \n", mat[2][0], mat[2][1], mat[2][2], mat[2][3], s0->z, d->z));
301 VSTRACE(("executing m4x3(4): (%f) (%f) \n", s0->w, d->w));
302 }
303
304 static void vshader_m3x4(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, D3DMATRIX43 mat) {
305 d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z;
306 d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z;
307 d->z = mat[2][0] * s0->x + mat[2][1] * s0->y + mat[2][2] * s0->z;
308 d->w = mat[3][0] * s0->x + mat[3][1] * s0->y + mat[3][2] * s0->z;
309 VSTRACE(("executing m3x4(1): mat=(%f, %f, %f) s0=(%f) d=(%f) \n", mat[0][0], mat[0][1], mat[0][2], s0->x, d->x));
310 VSTRACE(("executing m3x4(2): mat=(%f, %f, %f) (%f) (%f) \n", mat[1][0], mat[1][1], mat[1][2], s0->y, d->y));
311 VSTRACE(("executing m3x4(3): mat=(%f, %f, %f) X (%f) = (%f) \n", mat[2][0], mat[2][1], mat[2][2], s0->z, d->z));
312 VSTRACE(("executing m3x4(4): mat=(%f, %f, %f) (%f) (%f) \n", mat[3][0], mat[3][1], mat[3][2], s0->w, d->w));
313 }
314
315 static void vshader_m3x3(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, D3DMATRIX33 mat) {
316 d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z;
317 d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z;
318 d->z = mat[2][0] * s0->x + mat[2][1] * s0->y + mat[2][2] * s0->z;
319 d->w = 1.0f;
320 VSTRACE(("executing m3x3(1): mat=(%f, %f, %f) s0=(%f) d=(%f) \n", mat[0][0], mat[0][1], mat[0][2], s0->x, d->x));
321 VSTRACE(("executing m3x3(2): mat=(%f, %f, %f) (%f) (%f) \n", mat[1][0], mat[1][1], mat[1][2], s0->y, d->y));
322 VSTRACE(("executing m3x3(3): mat=(%f, %f, %f) X (%f) = (%f) \n", mat[2][0], mat[2][1], mat[2][2], s0->z, d->z));
323 VSTRACE(("executing m3x3(4): (%f) \n", d->w));
324 }
325
326 static void vshader_m3x2(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, D3DMATRIX23 mat) {
327 FIXME("check\n");
328 d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z;
329 d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z;
330 d->z = 0.0f;
331 d->w = 1.0f;
332 }
333
334 /**
335 * Version 2.0 specific
336 */
337 static void vshader_lrp(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1, WINED3DSHADERVECTOR* s2) {
338 d->x = s0->x * (s1->x - s2->x) + s2->x;
339 d->y = s0->y * (s1->y - s2->y) + s2->y;
340 d->z = s0->z * (s1->z - s2->z) + s2->z;
341 d->w = s0->w * (s1->w - s2->w) + s2->w;
342 }
343
344 static void vshader_crs(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
345 d->x = s0->y * s1->z - s0->z * s1->y;
346 d->y = s0->z * s1->x - s0->x * s1->z;
347 d->z = s0->x * s1->y - s0->y * s1->x;
348 d->w = 0.9f; /* w is undefined, so set it to something safeish */
349
350 VSTRACE(("executing crs: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
351 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
352 }
353
354 static void vshader_abs(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
355
356 d->x = fabsf(s0->x);
357 d->y = fabsf(s0->y);
358 d->z = fabsf(s0->z);
359 d->w = fabsf(s0->w);
360 VSTRACE(("executing abs: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
361 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
362 }
363
364 /* Stubs */
365
366 /* Def is C[n] = {n.nf, n.nf, n.nf, n.nf} */
367 static void vshader_def(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1, WINED3DSHADERVECTOR* s2, WINED3DSHADERVECTOR* s3) {
368 FIXME(" : Stub\n");
369 }
370
371 static void vshader_call(WINED3DSHADERVECTOR* d) {
372 FIXME(" : Stub\n");
373 }
374
375 static void vshader_callnz(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
376 FIXME(" : Stub\n");
377 }
378
379 static void vshader_loop(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
380 FIXME(" : Stub\n");
381 }
382
383 static void vshader_ret(void) {
384 FIXME(" : Stub\n");
385 }
386
387 static void vshader_endloop(void) {
388 FIXME(" : Stub\n");
389 }
390
391 static void vshader_dcl(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
392 FIXME(" : Stub\n");
393 }
394
395 static void vshader_pow(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
396 FIXME(" : Stub\n");
397 }
398
399 static void vshader_sgn(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
400 FIXME(" : Stub\n");
401 }
402
403 static void vshader_nrm(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
404 FIXME(" : Stub\n");
405 }
406
407 static void vshader_sincos3(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
408 FIXME(" : Stub\n");
409 }
410
411 static void vshader_sincos2(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1, WINED3DSHADERVECTOR* s2) {
412 FIXME(" : Stub\n");
413 }
414
415 static void vshader_rep(WINED3DSHADERVECTOR* d) {
416 FIXME(" : Stub\n");
417 }
418
419 static void vshader_endrep(void) {
420 FIXME(" : Stub\n");
421 }
422
423 static void vshader_if(WINED3DSHADERVECTOR* d) {
424 FIXME(" : Stub\n");
425 }
426
427 static void vshader_ifc(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
428 FIXME(" : Stub\n");
429 }
430
431 static void vshader_else(void) {
432 FIXME(" : Stub\n");
433 }
434
435 static void vshader_label(WINED3DSHADERVECTOR* d) {
436 FIXME(" : Stub\n");
437 }
438
439 static void vshader_endif(void) {
440 FIXME(" : Stub\n");
441 }
442
443 static void vshader_break(void) {
444 FIXME(" : Stub\n");
445 }
446
447 static void vshader_breakc(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
448 FIXME(" : Stub\n");
449 }
450
451 static void vshader_breakp(WINED3DSHADERVECTOR* d) {
452 FIXME(" : Stub\n");
453 }
454
455 static void vshader_mova(WINED3DSHADERVECTOR* d) {
456 FIXME(" : Stub\n");
457 }
458
459 static void vshader_defb(WINED3DSHADERVECTOR* d) {
460 FIXME(" : Stub\n");
461 }
462
463 static void vshader_defi(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1, WINED3DSHADERVECTOR* s2, WINED3DSHADERVECTOR* s3) {
464 FIXME(" : Stub\n");
465 }
466
467 static void vshader_setp(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
468 FIXME(" : Stub\n");
469 }
470
471 static void vshader_texldl(WINED3DSHADERVECTOR* d) {
472 FIXME(" : Stub\n");
473 }
474
475 CONST SHADER_OPCODE IWineD3DVertexShaderImpl_shader_ins[] = {
476
477 /* Arithmetic */
478 {WINED3DSIO_NOP, "nop", "NOP", 0, 0, vshader_nop, vshader_hw_map2gl, NULL, 0, 0},
479 {WINED3DSIO_MOV, "mov", "MOV", 1, 2, vshader_mov, vshader_hw_map2gl, shader_glsl_mov, 0, 0},
480 {WINED3DSIO_ADD, "add", "ADD", 1, 3, vshader_add, vshader_hw_map2gl, shader_glsl_arith, 0, 0},
481 {WINED3DSIO_SUB, "sub", "SUB", 1, 3, vshader_sub, vshader_hw_map2gl, shader_glsl_arith, 0, 0},
482 {WINED3DSIO_MAD, "mad", "MAD", 1, 4, vshader_mad, vshader_hw_map2gl, shader_glsl_mad, 0, 0},
483 {WINED3DSIO_MUL, "mul", "MUL", 1, 3, vshader_mul, vshader_hw_map2gl, shader_glsl_arith, 0, 0},
484 {WINED3DSIO_RCP, "rcp", "RCP", 1, 2, vshader_rcp, vshader_hw_map2gl, shader_glsl_rcp, 0, 0},
485 {WINED3DSIO_RSQ, "rsq", "RSQ", 1, 2, vshader_rsq, vshader_hw_map2gl, shader_glsl_map2gl, 0, 0},
486 {WINED3DSIO_DP3, "dp3", "DP3", 1, 3, vshader_dp3, vshader_hw_map2gl, shader_glsl_dot, 0, 0},
487 {WINED3DSIO_DP4, "dp4", "DP4", 1, 3, vshader_dp4, vshader_hw_map2gl, shader_glsl_dot, 0, 0},
488 {WINED3DSIO_MIN, "min", "MIN", 1, 3, vshader_min, vshader_hw_map2gl, shader_glsl_map2gl, 0, 0},
489 {WINED3DSIO_MAX, "max", "MAX", 1, 3, vshader_max, vshader_hw_map2gl, shader_glsl_map2gl, 0, 0},
490 {WINED3DSIO_SLT, "slt", "SLT", 1, 3, vshader_slt, vshader_hw_map2gl, shader_glsl_compare, 0, 0},
491 {WINED3DSIO_SGE, "sge", "SGE", 1, 3, vshader_sge, vshader_hw_map2gl, shader_glsl_compare, 0, 0},
492 {WINED3DSIO_ABS, "abs", "ABS", 1, 2, vshader_abs, vshader_hw_map2gl, shader_glsl_map2gl, 0, 0},
493 {WINED3DSIO_EXP, "exp", "EX2", 1, 2, vshader_exp, vshader_hw_map2gl, shader_glsl_map2gl, 0, 0},
494 {WINED3DSIO_LOG, "log", "LG2", 1, 2, vshader_log, vshader_hw_map2gl, shader_glsl_map2gl, 0, 0},
495 {WINED3DSIO_EXPP, "expp", "EXP", 1, 2, vshader_expp, vshader_hw_map2gl, shader_glsl_expp, 0, 0},
496 {WINED3DSIO_LOGP, "logp", "LOG", 1, 2, vshader_logp, vshader_hw_map2gl, shader_glsl_map2gl, 0, 0},
497 {WINED3DSIO_LIT, "lit", "LIT", 1, 2, vshader_lit, vshader_hw_map2gl, shader_glsl_lit, 0, 0},
498 {WINED3DSIO_DST, "dst", "DST", 1, 3, vshader_dst, vshader_hw_map2gl, shader_glsl_dst, 0, 0},
499 {WINED3DSIO_LRP, "lrp", "LRP", 1, 4, vshader_lrp, NULL, shader_glsl_lrp, 0, 0},
500 {WINED3DSIO_FRC, "frc", "FRC", 1, 2, vshader_frc, vshader_hw_map2gl, shader_glsl_map2gl, 0, 0},
501 {WINED3DSIO_POW, "pow", "POW", 1, 3, vshader_pow, NULL, shader_glsl_map2gl, 0, 0},
502 {WINED3DSIO_CRS, "crs", "XPS", 1, 3, vshader_crs, NULL, shader_glsl_map2gl, 0, 0},
503 /* TODO: sng can possibly be performed a s
504 RCP tmp, vec
505 MUL out, tmp, vec*/
506 {WINED3DSIO_SGN, "sgn", NULL, 1, 2, vshader_sgn, NULL, shader_glsl_map2gl, 0, 0},
507 /* TODO: xyz normalise can be performed as VS_ARB using one temporary register,
508 DP3 tmp , vec, vec;
509 RSQ tmp, tmp.x;
510 MUL vec.xyz, vec, tmp;
511 but I think this is better because it accounts for w properly.
512 DP3 tmp , vec, vec;
513 RSQ tmp, tmp.x;
514 MUL vec, vec, tmp;
515
516 */
517 {WINED3DSIO_NRM, "nrm", NULL, 1, 2, vshader_nrm, NULL, shader_glsl_map2gl, 0, 0},
518 {WINED3DSIO_SINCOS, "sincos", NULL, 1, 4, vshader_sincos2, NULL, shader_glsl_sincos, D3DVS_VERSION(2,0), D3DVS_VERSION(2,0)},
519 {WINED3DSIO_SINCOS, "sincos", NULL, 1, 2, vshader_sincos3, NULL, shader_glsl_sincos, D3DVS_VERSION(3,0), -1},
520
521 /* Matrix */
522 {WINED3DSIO_M4x4, "m4x4", "undefined", 1, 3, vshader_m4x4, vshader_hw_mnxn, shader_glsl_mnxn, 0, 0},
523 {WINED3DSIO_M4x3, "m4x3", "undefined", 1, 3, vshader_m4x3, vshader_hw_mnxn, shader_glsl_mnxn, 0, 0},
524 {WINED3DSIO_M3x4, "m3x4", "undefined", 1, 3, vshader_m3x4, vshader_hw_mnxn, shader_glsl_mnxn, 0, 0},
525 {WINED3DSIO_M3x3, "m3x3", "undefined", 1, 3, vshader_m3x3, vshader_hw_mnxn, shader_glsl_mnxn, 0, 0},
526 {WINED3DSIO_M3x2, "m3x2", "undefined", 1, 3, vshader_m3x2, vshader_hw_mnxn, shader_glsl_mnxn, 0, 0},
527
528 /* Declare registers */
529 {WINED3DSIO_DCL, "dcl", NULL, 0, 2, vshader_dcl, NULL, NULL, 0, 0},
530
531 /* Constant definitions */
532 {WINED3DSIO_DEF, "def", NULL, 1, 5, vshader_def, NULL, NULL, 0, 0},
533 {WINED3DSIO_DEFB, "defb", GLNAME_REQUIRE_GLSL, 1, 2, vshader_defb, NULL, NULL, 0, 0},
534 {WINED3DSIO_DEFI, "defi", GLNAME_REQUIRE_GLSL, 1, 5, vshader_defi, NULL, NULL, 0, 0},
535
536 /* Flow control - requires GLSL or software shaders */
537 {WINED3DSIO_REP , "rep", NULL, 0, 1, vshader_rep, NULL, shader_glsl_rep, D3DVS_VERSION(2,0), -1},
538 {WINED3DSIO_ENDREP, "endrep", NULL, 0, 0, vshader_endrep, NULL, shader_glsl_end, D3DVS_VERSION(2,0), -1},
539 {WINED3DSIO_IF, "if", NULL, 0, 1, vshader_if, NULL, shader_glsl_if, D3DVS_VERSION(2,0), -1},
540 {WINED3DSIO_IFC, "ifc", NULL, 0, 2, vshader_ifc, NULL, shader_glsl_ifc, D3DVS_VERSION(2,1), -1},
541 {WINED3DSIO_ELSE, "else", NULL, 0, 0, vshader_else, NULL, shader_glsl_else, D3DVS_VERSION(2,0), -1},
542 {WINED3DSIO_ENDIF, "endif", NULL, 0, 0, vshader_endif, NULL, shader_glsl_end, D3DVS_VERSION(2,0), -1},
543 {WINED3DSIO_BREAK, "break", NULL, 0, 0, vshader_break, NULL, shader_glsl_break, D3DVS_VERSION(2,1), -1},
544 {WINED3DSIO_BREAKC, "breakc", NULL, 0, 2, vshader_breakc, NULL, shader_glsl_breakc, D3DVS_VERSION(2,1), -1},
545 {WINED3DSIO_BREAKP, "breakp", GLNAME_REQUIRE_GLSL, 0, 1, vshader_breakp, NULL, NULL, 0, 0},
546 {WINED3DSIO_CALL, "call", NULL, 0, 1, vshader_call, NULL, shader_glsl_call, D3DVS_VERSION(2,0), -1},
547 {WINED3DSIO_CALLNZ, "callnz", NULL, 0, 2, vshader_callnz, NULL, shader_glsl_callnz, D3DVS_VERSION(2,0), -1},
548 {WINED3DSIO_LOOP, "loop", NULL, 0, 2, vshader_loop, NULL, shader_glsl_loop, D3DVS_VERSION(2,0), -1},
549 {WINED3DSIO_RET, "ret", NULL, 0, 0, vshader_ret, NULL, NULL, D3DVS_VERSION(2,0), -1},
550 {WINED3DSIO_ENDLOOP, "endloop", NULL, 0, 0, vshader_endloop, NULL, shader_glsl_end, D3DVS_VERSION(2,0), -1},
551 {WINED3DSIO_LABEL, "label", NULL, 0, 1, vshader_label, NULL, shader_glsl_label, D3DVS_VERSION(2,0), -1},
552
553 {WINED3DSIO_MOVA, "mova", GLNAME_REQUIRE_GLSL, 1, 2, vshader_mova, NULL, shader_glsl_mov, 0, 0},
554 {WINED3DSIO_SETP, "setp", GLNAME_REQUIRE_GLSL, 1, 3, vshader_setp, NULL, NULL, 0, 0},
555 {WINED3DSIO_TEXLDL, "texdl", GLNAME_REQUIRE_GLSL, 1, 2, vshader_texldl, NULL, NULL, 0, 0},
556 {0, NULL, NULL, 0, 0, NULL, NULL, 0, 0}
557 };
558
559 static void vshader_set_limits(
560 IWineD3DVertexShaderImpl *This) {
561
562 This->baseShader.limits.texcoord = 0;
563 This->baseShader.limits.attributes = 16;
564 This->baseShader.limits.packed_input = 0;
565
566 /* Must match D3DCAPS9.MaxVertexShaderConst: at least 256 for vs_2_0 */
567 This->baseShader.limits.constant_float = GL_LIMITS(vshader_constantsF);
568
569 switch (This->baseShader.hex_version) {
570 case D3DVS_VERSION(1,0):
571 case D3DVS_VERSION(1,1):
572 This->baseShader.limits.temporary = 12;
573 This->baseShader.limits.constant_bool = 0;
574 This->baseShader.limits.constant_int = 0;
575 This->baseShader.limits.address = 1;
576 This->baseShader.limits.packed_output = 0;
577 This->baseShader.limits.sampler = 0;
578 This->baseShader.limits.label = 0;
579 break;
580
581 case D3DVS_VERSION(2,0):
582 case D3DVS_VERSION(2,1):
583 This->baseShader.limits.temporary = 12;
584 This->baseShader.limits.constant_bool = 16;
585 This->baseShader.limits.constant_int = 16;
586 This->baseShader.limits.address = 1;
587 This->baseShader.limits.packed_output = 0;
588 This->baseShader.limits.sampler = 0;
589 This->baseShader.limits.label = 16;
590 break;
591
592 case D3DVS_VERSION(3,0):
593 This->baseShader.limits.temporary = 32;
594 This->baseShader.limits.constant_bool = 32;
595 This->baseShader.limits.constant_int = 32;
596 This->baseShader.limits.address = 1;
597 This->baseShader.limits.packed_output = 12;
598 This->baseShader.limits.sampler = 4;
599 This->baseShader.limits.label = 16; /* FIXME: 2048 */
600 break;
601
602 default: This->baseShader.limits.temporary = 12;
603 This->baseShader.limits.constant_bool = 16;
604 This->baseShader.limits.constant_int = 16;
605 This->baseShader.limits.address = 1;
606 This->baseShader.limits.packed_output = 0;
607 This->baseShader.limits.sampler = 0;
608 This->baseShader.limits.label = 16;
609 FIXME("Unrecognized vertex shader version %#x\n",
610 This->baseShader.hex_version);
611 }
612 }
613
614 /* This is an internal function,
615 * used to create fake semantics for shaders
616 * that don't have them - d3d8 shaders where the declaration
617 * stores the register for each input
618 */
619 static void vshader_set_input(
620 IWineD3DVertexShaderImpl* This,
621 unsigned int regnum,
622 BYTE usage, BYTE usage_idx) {
623
624 /* Fake usage: set reserved bit, usage, usage_idx */
625 DWORD usage_token = (0x1 << 31) |
626 (usage << WINED3DSP_DCL_USAGE_SHIFT) | (usage_idx << WINED3DSP_DCL_USAGEINDEX_SHIFT);
627
628 /* Fake register; set reserved bit, regnum, type: input, wmask: all */
629 DWORD reg_token = (0x1 << 31) |
630 WINED3DSP_WRITEMASK_ALL | (WINED3DSPR_INPUT << WINED3DSP_REGTYPE_SHIFT) | regnum;
631
632 This->semantics_in[regnum].usage = usage_token;
633 This->semantics_in[regnum].reg = reg_token;
634 }
635
636 BOOL vshader_get_input(
637 IWineD3DVertexShader* iface,
638 BYTE usage_req, BYTE usage_idx_req,
639 unsigned int* regnum) {
640
641 IWineD3DVertexShaderImpl* This = (IWineD3DVertexShaderImpl*) iface;
642 int i;
643
644 for (i = 0; i < MAX_ATTRIBS; i++) {
645 DWORD usage_token = This->semantics_in[i].usage;
646 DWORD usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
647 DWORD usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
648
649 if (usage_token && (usage == usage_req && usage_idx == usage_idx_req)) {
650 *regnum = i;
651 return TRUE;
652 }
653 }
654 return FALSE;
655 }
656
657 BOOL vshader_input_is_color(
658 IWineD3DVertexShader* iface,
659 unsigned int regnum) {
660
661 IWineD3DVertexShaderImpl* This = (IWineD3DVertexShaderImpl*) iface;
662 IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
663
664 DWORD usage_token = This->semantics_in[regnum].usage;
665 DWORD usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
666 DWORD usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
667
668 IWineD3DVertexDeclarationImpl *vertexDeclaration = NULL;
669 if (This->vertexDeclaration) {
670 /* D3D8 declaration */
671 vertexDeclaration = (IWineD3DVertexDeclarationImpl *)This->vertexDeclaration;
672 } else {
673 /* D3D9 declaration */
674 vertexDeclaration = (IWineD3DVertexDeclarationImpl *) (deviceImpl->stateBlock->vertexDecl);
675 }
676
677 if (vertexDeclaration) {
678 int i;
679 /* Find the declaration element that matches our register, then check
680 * if it has D3DCOLOR as it's type. This works for both d3d8 and d3d9. */
681 for (i = 0; i < vertexDeclaration->declarationWNumElements-1; ++i) {
682 WINED3DVERTEXELEMENT *element = vertexDeclaration->pDeclarationWine + i;
683 if ((element->Usage == usage && element->UsageIndex == usage_idx)) {
684 return element->Type == WINED3DDECLTYPE_D3DCOLOR;
685 }
686 }
687 }
688
689 ERR("Either no vertexdeclaration present, or register not matched. This should never happen.\n");
690 return FALSE;
691 }
692
693 /** Generate a vertex shader string using either GL_VERTEX_PROGRAM_ARB
694 or GLSL and send it to the card */
695 static VOID IWineD3DVertexShaderImpl_GenerateShader(
696 IWineD3DVertexShader *iface,
697 shader_reg_maps* reg_maps,
698 CONST DWORD *pFunction) {
699
700 IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
701 SHADER_BUFFER buffer;
702
703 #if 0 /* FIXME: Use the buffer that is held by the device, this is ok since fixups will be skipped for software shaders
704 it also requires entering a critical section but cuts down the runtime footprint of wined3d and any memory fragmentation that may occur... */
705 if (This->device->fixupVertexBufferSize < SHADER_PGMSIZE) {
706 HeapFree(GetProcessHeap(), 0, This->fixupVertexBuffer);
707 This->fixupVertexBuffer = HeapAlloc(GetProcessHeap() , 0, SHADER_PGMSIZE);
708 This->fixupVertexBufferSize = PGMSIZE;
709 This->fixupVertexBuffer[0] = 0;
710 }
711 buffer.buffer = This->device->fixupVertexBuffer;
712 #else
713 buffer.buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, SHADER_PGMSIZE);
714 #endif
715 buffer.bsize = 0;
716 buffer.lineNo = 0;
717
718 if (This->baseShader.shader_mode == SHADER_GLSL) {
719
720 /* Create the hw GLSL shader program and assign it as the baseShader.prgId */
721 GLhandleARB shader_obj = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
722
723 /* Base Declarations */
724 shader_generate_glsl_declarations( (IWineD3DBaseShader*) This, reg_maps, &buffer, &GLINFO_LOCATION);
725
726 /* Base Shader Body */
727 shader_generate_main( (IWineD3DBaseShader*) This, &buffer, reg_maps, pFunction);
728
729 /* Unpack 3.0 outputs */
730 if (This->baseShader.hex_version >= D3DVS_VERSION(3,0))
731 vshader_glsl_output_unpack(&buffer, This->semantics_out);
732
733 /* Clamp the fog from 0 to 1 if it's used */
734 if (reg_maps->fog) {
735 This->usesFog = 1;
736 shader_addline(&buffer, "gl_FogFragCoord = clamp(gl_FogFragCoord, 0.0, 1.0);\n");
737 }
738
739 /* Write the final position.
740 *
741 * OpenGL coordinates specify the center of the pixel while d3d coords specify
742 * the corner. The offsets are stored in z and w in the 2nd row of the projection
743 * matrix to avoid wasting a free shader constant. Add them to the w and z coord
744 * of the 2nd row
745 */
746 shader_addline(&buffer, "gl_Position.x = gl_Position.x + posFixup[2];\n");
747 shader_addline(&buffer, "gl_Position.y = gl_Position.y + posFixup[3];\n");
748 /* Account for any inverted textures (render to texture case) by reversing the y coordinate
749 * (this is handled in drawPrim() when it sets the MODELVIEW and PROJECTION matrices)
750 */
751 shader_addline(&buffer, "gl_Position.y = gl_Position.y * posFixup[1];\n");
752
753 shader_addline(&buffer, "}\n\0");
754
755 TRACE("Compiling shader object %u\n", shader_obj);
756 GL_EXTCALL(glShaderSourceARB(shader_obj, 1, (const char**)&buffer.buffer, NULL));
757 GL_EXTCALL(glCompileShaderARB(shader_obj));
758 print_glsl_info_log(&GLINFO_LOCATION, shader_obj);
759
760 /* Store the shader object */
761 This->baseShader.prgId = shader_obj;
762
763 } else if (This->baseShader.shader_mode == SHADER_ARB) {
764
765 /* Create the hw ARB shader */
766 shader_addline(&buffer, "!!ARBvp1.0\n");
767
768 /* Mesa supports only 95 constants */
769 if (GL_VEND(MESA) || GL_VEND(WINE))
770 This->baseShader.limits.constant_float =
771 min(95, This->baseShader.limits.constant_float);
772
773 /* Base Declarations */
774 shader_generate_arb_declarations( (IWineD3DBaseShader*) This, reg_maps, &buffer, &GLINFO_LOCATION);
775
776 /* We need a constant to fixup the final position */
777 shader_addline(&buffer, "PARAM posFixup = program.env[%d];\n", ARB_SHADER_PRIVCONST_POS);
778
779 if (reg_maps->fog) {
780 This->usesFog = 1;
781 shader_addline(&buffer, "TEMP TMP_FOG;\n");
782 }
783
784 /* Base Shader Body */
785 shader_generate_main( (IWineD3DBaseShader*) This, &buffer, reg_maps, pFunction);
786
787 /* Make sure the fog value is positive - values above 1.0 are ignored */
788 if (reg_maps->fog)
789 shader_addline(&buffer, "MAX result.fogcoord, TMP_FOG, 0.0;\n");
790
791 /* Write the final position.
792 *
793 * OpenGL coordinates specify the center of the pixel while d3d coords specify
794 * the corner. The offsets are stored in the 2nd row of the projection matrix,
795 * the x offset in z and the y offset in w. Add them to the resulting position
796 */
797 shader_addline(&buffer, "ADD TMP_OUT.x, TMP_OUT.x, posFixup.z;\n");
798 shader_addline(&buffer, "ADD TMP_OUT.y, TMP_OUT.y, posFixup.w;\n");
799 /* Account for any inverted textures (render to texture case) by reversing the y coordinate
800 * (this is handled in drawPrim() when it sets the MODELVIEW and PROJECTION matrices)
801 */
802 shader_addline(&buffer, "MUL TMP_OUT.y, TMP_OUT.y, posFixup.y;\n");
803
804 shader_addline(&buffer, "MOV result.position, TMP_OUT;\n");
805
806 shader_addline(&buffer, "END\n\0");
807
808 /* TODO: change to resource.glObjectHandle or something like that */
809 GL_EXTCALL(glGenProgramsARB(1, &This->baseShader.prgId));
810
811 TRACE("Creating a hw vertex shader, prg=%d\n", This->baseShader.prgId);
812 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, This->baseShader.prgId));
813
814 TRACE("Created hw vertex shader, prg=%d\n", This->baseShader.prgId);
815 /* Create the program and check for errors */
816 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
817 buffer.bsize, buffer.buffer));
818
819 if (glGetError() == GL_INVALID_OPERATION) {
820 GLint errPos;
821 glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos);
822 FIXME("HW VertexShader Error at position %d: %s\n",
823 errPos, debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
824 This->baseShader.prgId = -1;
825 }
826 }
827
828 #if 1 /* if were using the data buffer of device then we don't need to free it */
829 HeapFree(GetProcessHeap(), 0, buffer.buffer);
830 #endif
831 }
832
833 BOOL IWineD3DVertexShaderImpl_ExecuteHAL(IWineD3DVertexShader* iface, WINEVSHADERINPUTDATA* input, WINEVSHADEROUTPUTDATA* output) {
834 /**
835 * TODO: use the NV_vertex_program (or 1_1) extension
836 * and specifics vendors (ARB_vertex_program??) variants for it
837 */
838 return TRUE;
839 }
840
841 HRESULT WINAPI IWineD3DVertexShaderImpl_ExecuteSW(IWineD3DVertexShader* iface, WINEVSHADERINPUTDATA* input, WINEVSHADEROUTPUTDATA* output) {
842 IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
843 DWORD opcode_token;
844
845 /** Vertex Shader Temporary Registers */
846 WINED3DSHADERVECTOR R[12];
847 /*D3DSHADERSCALAR A0;*/
848 WINED3DSHADERVECTOR A[1];
849 /** temporary Vector for modifier management */
850 WINED3DSHADERVECTOR d;
851 WINED3DSHADERVECTOR s[3];
852 /** parser datas */
853 const DWORD* pToken = This->baseShader.function;
854 const SHADER_OPCODE* curOpcode = NULL;
855 /** functions parameters */
856 WINED3DSHADERVECTOR* p[6];
857 WINED3DSHADERVECTOR* p_send[6];
858 DWORD i;
859
860 /** init temporary register */
861 memset(R, 0, 12 * sizeof(WINED3DSHADERVECTOR));
862
863 /* vshader_program_parse(vshader); */
864 #if 0 /* Must not be 1 in cvs */
865 TRACE("Input:\n");
866 TRACE_VSVECTOR(This->data->C[0]);
867 TRACE_VSVECTOR(This->data->C[1]);
868 TRACE_VSVECTOR(This->data->C[2]);
869 TRACE_VSVECTOR(This->data->C[3]);
870 TRACE_VSVECTOR(This->data->C[4]);
871 TRACE_VSVECTOR(This->data->C[5]);
872 TRACE_VSVECTOR(This->data->C[6]);
873 TRACE_VSVECTOR(This->data->C[7]);
874 TRACE_VSVECTOR(This->data->C[8]);
875 TRACE_VSVECTOR(This->data->C[64]);
876 TRACE_VSVECTOR(input->V[D3DVSDE_POSITION]);
877 TRACE_VSVECTOR(input->V[D3DVSDE_BLENDWEIGHT]);
878 TRACE_VSVECTOR(input->V[D3DVSDE_BLENDINDICES]);
879 TRACE_VSVECTOR(input->V[D3DVSDE_NORMAL]);
880 TRACE_VSVECTOR(input->V[D3DVSDE_PSIZE]);
881 TRACE_VSVECTOR(input->V[D3DVSDE_DIFFUSE]);
882 TRACE_VSVECTOR(input->V[D3DVSDE_SPECULAR]);
883 TRACE_VSVECTOR(input->V[D3DVSDE_TEXCOORD0]);
884 TRACE_VSVECTOR(input->V[D3DVSDE_TEXCOORD1]);
885 #endif
886
887 TRACE_VSVECTOR(vshader->data->C[64]);
888 /* TODO: Run through all the tokens and find and labels, if, endifs, loops etc...., and make a labels list */
889
890 /* the first dword is the version tag */
891 /* TODO: parse it */
892
893 if (shader_is_vshader_version(*pToken)) { /** version */
894 ++pToken;
895 }
896 while (D3DVS_END() != *pToken) {
897 if (shader_is_comment(*pToken)) { /** comment */
898 DWORD comment_len = (*pToken & WINED3DSI_COMMENTSIZE_MASK) >> WINED3DSI_COMMENTSIZE_SHIFT;
899 ++pToken;
900 pToken += comment_len;
901 continue ;
902 }
903
904 opcode_token = *pToken++;
905 curOpcode = shader_get_opcode((IWineD3DBaseShader*) This, opcode_token);
906
907 if (NULL == curOpcode) {
908 FIXME("Unrecognized opcode: token=%08x\n", opcode_token);
909 pToken += shader_skip_unrecognized((IWineD3DBaseShader*) This, pToken);
910 /* return FALSE; */
911
912 } else {
913 if (curOpcode->num_params > 0) {
914 /* TRACE(">> execting opcode: pos=%d opcode_name=%s token=%08lX\n", pToken - vshader->function, curOpcode->name, *pToken); */
915 for (i = 0; i < curOpcode->num_params; ++i) {
916 DWORD reg = pToken[i] & WINED3DSP_REGNUM_MASK;
917 DWORD regtype = shader_get_regtype(pToken[i]);
918
919 switch (regtype) {
920 case WINED3DSPR_TEMP:
921 /* TRACE("p[%d]=R[%d]\n", i, reg); */
922 p[i] = &R[reg];
923 break;
924 case WINED3DSPR_INPUT:
925 /* TRACE("p[%d]=V[%s]\n", i, VertexShaderDeclRegister[reg]); */
926 p[i] = &input->V[reg];
927 break;
928 case WINED3DSPR_CONST:
929 if (pToken[i] & D3DVS_ADDRMODE_RELATIVE) {
930 p[i] = &This->data->C[(DWORD) A[0].x + reg];
931 } else {
932 p[i] = &This->data->C[reg];
933 }
934 break;
935 case WINED3DSPR_ADDR: /* case WINED3DSPR_TEXTURE: */
936 if (0 != reg) {
937 ERR("cannot handle address registers != a0, forcing use of a0\n");
938 reg = 0;
939 }
940 /* TRACE("p[%d]=A[%d]\n", i, reg); */
941 p[i] = &A[reg];
942 break;
943 case WINED3DSPR_RASTOUT:
944 switch (reg) {
945 case D3DSRO_POSITION:
946 p[i] = &output->oPos;
947 break;
948 case D3DSRO_FOG:
949 p[i] = &output->oFog;
950 break;
951 case D3DSRO_POINT_SIZE:
952 p[i] = &output->oPts;
953 break;
954 }
955 break;
956 case WINED3DSPR_ATTROUT:
957 /* TRACE("p[%d]=oD[%d]\n", i, reg); */
958 p[i] = &output->oD[reg];
959 break;
960 case WINED3DSPR_TEXCRDOUT:
961 /* TRACE("p[%d]=oT[%d]\n", i, reg); */
962 p[i] = &output->oT[reg];
963 break;
964 /* TODO Decls and defs */
965 #if 0
966 case WINED3DSPR_DCL:
967 case WINED3DSPR_DEF:
968 #endif
969 default:
970 break;
971 }
972
973 if (i > 0) { /* input reg */
974 DWORD swizzle = (pToken[i] & WINED3DVS_SWIZZLE_MASK) >> WINED3DVS_SWIZZLE_SHIFT;
975 UINT isNegative = ((pToken[i] & WINED3DSP_SRCMOD_MASK) == WINED3DSPSM_NEG);
976
977 if (!isNegative && (WINED3DVS_NOSWIZZLE >> WINED3DVS_SWIZZLE_SHIFT) == swizzle) {
978 /* TRACE("p[%d] not swizzled\n", i); */
979 p_send[i] = p[i];
980 } else {
981 DWORD swizzle_x = swizzle & 0x03;
982 DWORD swizzle_y = (swizzle >> 2) & 0x03;
983 DWORD swizzle_z = (swizzle >> 4) & 0x03;
984 DWORD swizzle_w = (swizzle >> 6) & 0x03;
985 /* TRACE("p[%d] swizzled\n", i); */
986 float* tt = (float*) p[i];
987 s[i].x = (isNegative) ? -tt[swizzle_x] : tt[swizzle_x];
988 s[i].y = (isNegative) ? -tt[swizzle_y] : tt[swizzle_y];
989 s[i].z = (isNegative) ? -tt[swizzle_z] : tt[swizzle_z];
990 s[i].w = (isNegative) ? -tt[swizzle_w] : tt[swizzle_w];
991 p_send[i] = &s[i];
992 }
993 } else { /* output reg */
994 if ((pToken[i] & WINED3DSP_WRITEMASK_ALL) == WINED3DSP_WRITEMASK_ALL) {
995 p_send[i] = p[i];
996 } else {
997 p_send[i] = &d; /* to be post-processed for modifiers management */
998 }
999 }
1000 }
1001 }
1002
1003 switch (curOpcode->num_params) {
1004 case 0:
1005 curOpcode->soft_fct();
1006 break;
1007 case 1:
1008 curOpcode->soft_fct(p_send[0]);
1009 break;
1010 case 2:
1011 curOpcode->soft_fct(p_send[0], p_send[1]);
1012 break;
1013 case 3:
1014 curOpcode->soft_fct(p_send[0], p_send[1], p_send[2]);
1015 break;
1016 case 4:
1017 curOpcode->soft_fct(p_send[0], p_send[1], p_send[2], p_send[3]);
1018 break;
1019 case 5:
1020 curOpcode->soft_fct(p_send[0], p_send[1], p_send[2], p_send[3], p_send[4]);
1021 break;
1022 case 6:
1023 curOpcode->soft_fct(p_send[0], p_send[1], p_send[2], p_send[3], p_send[4], p_send[5]);
1024 break;
1025 default:
1026 ERR("%s too many params: %u\n", curOpcode->name, curOpcode->num_params);
1027 }
1028
1029 /* check if output reg modifier post-process */
1030 if (curOpcode->num_params > 0 &&
1031 (pToken[0] & WINED3DSP_WRITEMASK_ALL) != WINED3DSP_WRITEMASK_ALL) {
1032
1033 if (pToken[0] & WINED3DSP_WRITEMASK_0) p[0]->x = d.x;
1034 if (pToken[0] & WINED3DSP_WRITEMASK_1) p[0]->y = d.y;
1035 if (pToken[0] & WINED3DSP_WRITEMASK_2) p[0]->z = d.z;
1036 if (pToken[0] & WINED3DSP_WRITEMASK_3) p[0]->w = d.w;
1037 }
1038 #if 0
1039 TRACE_VSVECTOR(output->oPos);
1040 TRACE_VSVECTOR(output->oD[0]);
1041 TRACE_VSVECTOR(output->oD[1]);
1042 TRACE_VSVECTOR(output->oT[0]);
1043 TRACE_VSVECTOR(output->oT[1]);
1044 TRACE_VSVECTOR(R[0]);
1045 TRACE_VSVECTOR(R[1]);
1046 TRACE_VSVECTOR(R[2]);
1047 TRACE_VSVECTOR(R[3]);
1048 TRACE_VSVECTOR(R[4]);
1049 TRACE_VSVECTOR(R[5]);
1050 #endif
1051
1052 /* to next opcode token */
1053 pToken += curOpcode->num_params;
1054 }
1055 #if 0
1056 TRACE("End of current instruction:\n");
1057 TRACE_VSVECTOR(output->oPos);
1058 TRACE_VSVECTOR(output->oD[0]);
1059 TRACE_VSVECTOR(output->oD[1]);
1060 TRACE_VSVECTOR(output->oT[0]);
1061 TRACE_VSVECTOR(output->oT[1]);
1062 TRACE_VSVECTOR(R[0]);
1063 TRACE_VSVECTOR(R[1]);
1064 TRACE_VSVECTOR(R[2]);
1065 TRACE_VSVECTOR(R[3]);
1066 TRACE_VSVECTOR(R[4]);
1067 TRACE_VSVECTOR(R[5]);
1068 #endif
1069 }
1070 #if 0 /* Must not be 1 in cvs */
1071 TRACE("Output:\n");
1072 TRACE_VSVECTOR(output->oPos);
1073 TRACE_VSVECTOR(output->oD[0]);
1074 TRACE_VSVECTOR(output->oD[1]);
1075 TRACE_VSVECTOR(output->oT[0]);
1076 TRACE_VSVECTOR(output->oT[1]);
1077 #endif
1078 return WINED3D_OK;
1079 }
1080
1081 /* *******************************************
1082 IWineD3DVertexShader IUnknown parts follow
1083 ******************************************* */
1084 static HRESULT WINAPI IWineD3DVertexShaderImpl_QueryInterface(IWineD3DVertexShader *iface, REFIID riid, LPVOID *ppobj)
1085 {
1086 IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1087 TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
1088 if (IsEqualGUID(riid, &IID_IUnknown)
1089 || IsEqualGUID(riid, &IID_IWineD3DBase)
1090 || IsEqualGUID(riid, &IID_IWineD3DBaseShader)
1091 || IsEqualGUID(riid, &IID_IWineD3DVertexShader)) {
1092 IUnknown_AddRef(iface);
1093 *ppobj = This;
1094 return S_OK;
1095 }
1096 *ppobj = NULL;
1097 return E_NOINTERFACE;
1098 }
1099
1100 static ULONG WINAPI IWineD3DVertexShaderImpl_AddRef(IWineD3DVertexShader *iface) {
1101 IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1102 TRACE("(%p) : AddRef increasing from %d\n", This, This->ref);
1103 return InterlockedIncrement(&This->ref);
1104 }
1105
1106 static ULONG WINAPI IWineD3DVertexShaderImpl_Release(IWineD3DVertexShader *iface) {
1107 IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1108 ULONG ref;
1109 TRACE("(%p) : Releasing from %d\n", This, This->ref);
1110 ref = InterlockedDecrement(&This->ref);
1111 if (ref == 0) {
1112 if (This->vertexDeclaration) IWineD3DVertexDeclaration_Release(This->vertexDeclaration);
1113 if (This->baseShader.shader_mode == SHADER_GLSL && This->baseShader.prgId != 0) {
1114 /* If this shader is still attached to a program, GL will perform a lazy delete */
1115 TRACE("Deleting shader object %u\n", This->baseShader.prgId);
1116 GL_EXTCALL(glDeleteObjectARB(This->baseShader.prgId));
1117 checkGLcall("glDeleteObjectARB");
1118 }
1119 shader_delete_constant_list(&This->baseShader.constantsF);
1120 shader_delete_constant_list(&This->baseShader.constantsB);
1121 shader_delete_constant_list(&This->baseShader.constantsI);
1122 HeapFree(GetProcessHeap(), 0, This);
1123
1124 }
1125 return ref;
1126 }
1127
1128 /* *******************************************
1129 IWineD3DVertexShader IWineD3DVertexShader parts follow
1130 ******************************************* */
1131
1132 static HRESULT WINAPI IWineD3DVertexShaderImpl_GetParent(IWineD3DVertexShader *iface, IUnknown** parent){
1133 IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1134
1135 *parent = This->parent;
1136 IUnknown_AddRef(*parent);
1137 TRACE("(%p) : returning %p\n", This, *parent);
1138 return WINED3D_OK;
1139 }
1140
1141 static HRESULT WINAPI IWineD3DVertexShaderImpl_GetDevice(IWineD3DVertexShader* iface, IWineD3DDevice **pDevice){
1142 IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1143 IWineD3DDevice_AddRef(This->baseShader.device);
1144 *pDevice = This->baseShader.device;
1145 TRACE("(%p) returning %p\n", This, *pDevice);
1146 return WINED3D_OK;
1147 }
1148
1149 static HRESULT WINAPI IWineD3DVertexShaderImpl_GetFunction(IWineD3DVertexShader* impl, VOID* pData, UINT* pSizeOfData) {
1150 IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)impl;
1151 TRACE("(%p) : pData(%p), pSizeOfData(%p)\n", This, pData, pSizeOfData);
1152
1153 if (NULL == pData) {
1154 *pSizeOfData = This->baseShader.functionLength;
1155 return WINED3D_OK;
1156 }
1157 if (*pSizeOfData < This->baseShader.functionLength) {
1158 *pSizeOfData = This->baseShader.functionLength;
1159 return WINED3DERR_MOREDATA;
1160 }
1161 if (NULL == This->baseShader.function) { /* no function defined */
1162 TRACE("(%p) : GetFunction no User Function defined using NULL to %p\n", This, pData);
1163 (*(DWORD **) pData) = NULL;
1164 } else {
1165 if(This->baseShader.functionLength == 0){
1166
1167 }
1168 TRACE("(%p) : GetFunction copying to %p\n", This, pData);
1169 memcpy(pData, This->baseShader.function, This->baseShader.functionLength);
1170 }
1171 return WINED3D_OK;
1172 }
1173
1174 /* Note that for vertex shaders CompileShader isn't called until the
1175 * shader is first used. The reason for this is that we need the vertex
1176 * declaration the shader will be used with in order to determine if
1177 * the data in a register is of type D3DCOLOR, and needs swizzling. */
1178 static HRESULT WINAPI IWineD3DVertexShaderImpl_SetFunction(IWineD3DVertexShader *iface, CONST DWORD *pFunction) {
1179
1180 IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface;
1181 IWineD3DDeviceImpl *deviceImpl = (IWineD3DDeviceImpl *) This->baseShader.device;
1182 HRESULT hr;
1183 shader_reg_maps *reg_maps = &This->baseShader.reg_maps;
1184
1185 TRACE("(%p) : pFunction %p\n", iface, pFunction);
1186
1187 /* First pass: trace shader */
1188 shader_trace_init((IWineD3DBaseShader*) This, pFunction);
1189 vshader_set_limits(This);
1190
1191 /* Initialize immediate constant lists */
1192 list_init(&This->baseShader.constantsF);
1193 list_init(&This->baseShader.constantsB);
1194 list_init(&This->baseShader.constantsI);
1195
1196 /* Preload semantics for d3d8 shaders */
1197 if (This->vertexDeclaration) {
1198 IWineD3DVertexDeclarationImpl* vdecl = (IWineD3DVertexDeclarationImpl*) This->vertexDeclaration;
1199 int i;
1200 for (i = 0; i < vdecl->declarationWNumElements - 1; ++i) {
1201 WINED3DVERTEXELEMENT* element = vdecl->pDeclarationWine + i;
1202 vshader_set_input(This, element->Reg, element->Usage, element->UsageIndex);
1203 }
1204 }
1205
1206 /* Second pass: figure out registers used, semantics, etc.. */
1207 memset(reg_maps, 0, sizeof(shader_reg_maps));
1208 hr = shader_get_registers_used((IWineD3DBaseShader*) This, reg_maps,
1209 This->semantics_in, This->semantics_out, pFunction, deviceImpl->stateBlock);
1210 if (hr != WINED3D_OK) return hr;
1211
1212 This->baseShader.shader_mode = deviceImpl->vs_selected_mode;
1213
1214 /* copy the function ... because it will certainly be released by application */
1215 if (NULL != pFunction) {
1216 This->baseShader.function = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->baseShader.functionLength);
1217 if (!This->baseShader.function) return E_OUTOFMEMORY;
1218 memcpy((void *)This->baseShader.function, pFunction, This->baseShader.functionLength);
1219 } else {
1220 This->baseShader.function = NULL;
1221 }
1222
1223 return WINED3D_OK;
1224 }
1225
1226 static HRESULT WINAPI IWineD3DVertexShaderImpl_CompileShader(IWineD3DVertexShader *iface) {
1227 IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1228 CONST DWORD *function = This->baseShader.function;
1229
1230 TRACE("(%p) : function %p\n", iface, function);
1231
1232 /* We're already compiled. */
1233 if (This->baseShader.is_compiled) return WINED3D_OK;
1234
1235 /* We don't need to compile */
1236 if (!function || This->baseShader.shader_mode == SHADER_SW) {
1237 This->baseShader.is_compiled = TRUE;
1238 return WINED3D_OK;
1239 }
1240
1241 /* Generate the HW shader */
1242 TRACE("(%p) : Generating hardware program\n", This);
1243 IWineD3DVertexShaderImpl_GenerateShader(iface, &This->baseShader.reg_maps, function);
1244
1245 This->baseShader.is_compiled = TRUE;
1246
1247 return WINED3D_OK;
1248 }
1249
1250 const IWineD3DVertexShaderVtbl IWineD3DVertexShader_Vtbl =
1251 {
1252 /*** IUnknown methods ***/
1253 IWineD3DVertexShaderImpl_QueryInterface,
1254 IWineD3DVertexShaderImpl_AddRef,
1255 IWineD3DVertexShaderImpl_Release,
1256 /*** IWineD3DBase methods ***/
1257 IWineD3DVertexShaderImpl_GetParent,
1258 /*** IWineD3DBaseShader methods ***/
1259 IWineD3DVertexShaderImpl_SetFunction,
1260 IWineD3DVertexShaderImpl_CompileShader,
1261 /*** IWineD3DVertexShader methods ***/
1262 IWineD3DVertexShaderImpl_GetDevice,
1263 IWineD3DVertexShaderImpl_GetFunction
1264 };