?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Spelling fix.
[wine/wine-kai.git] / dlls / d3d8 / shader.c
blob873bc05847e3352d83b16c10537b877c3bc0f3f8
1 /*
2 * shaders implementation
3 *
4 * Copyright 2002 Raphael Junqueira
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "config.h"
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winuser.h"
26 #include "wingdi.h"
27 #include "wine/debug.h"
28
29 #include <math.h>
30
31 #include "d3d8_private.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
34
35 /* Shader debugging - Change the following line to enable debugging of software
36 vertex shaders */
37 #if 0 /* Must not be 1 in cvs version */
38 # define VSTRACE(A) TRACE A
39 # define TRACE_VSVECTOR(name) TRACE( #name "=(%f, %f, %f, %f)\n", name.x, name.y, name.z, name.w)
40 #else
41 # define VSTRACE(A)
42 # define TRACE_VSVECTOR(name)
43 #endif
44
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 typedef void (*shader_fct_t)();
79
80 typedef struct SHADER_OPCODE {
81 CONST BYTE opcode;
82 const char* name;
83 CONST UINT num_params;
84 shader_fct_t soft_fct;
85 DWORD min_version;
86 DWORD max_version;
87 } SHADER_OPCODE;
88
89 /*******************************
90 * vshader functions software VM
91 */
92
93 void vshader_add(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
94 d->x = s0->x + s1->x;
95 d->y = s0->y + s1->y;
96 d->z = s0->z + s1->z;
97 d->w = s0->w + s1->w;
98 VSTRACE(("executing add: 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 void vshader_dp3(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
103 d->x = d->y = d->z = d->w = s0->x * s1->x + s0->y * s1->y + s0->z * s1->z;
104 VSTRACE(("executing dp3: 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 void vshader_dp4(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
109 d->x = d->y = d->z = d->w = s0->x * s1->x + s0->y * s1->y + s0->z * s1->z + s0->w * s1->w;
110 VSTRACE(("executing dp4: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
111 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
112 }
113
114 void vshader_dst(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
115 d->x = 1.0f;
116 d->y = s0->y * s1->y;
117 d->z = s0->z;
118 d->w = s1->w;
119 VSTRACE(("executing dst: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
120 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
121 }
122
123 void vshader_expp(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
124 float tmp_f = floorf(s0->w);
125 DWORD tmp_d = 0;
126 tmp_f = powf(2.0f, s0->w);
127 tmp_d = *((DWORD*) &tmp_f) & 0xFFFFFF00;
128
129 d->x = powf(2.0f, tmp_f);
130 d->y = s0->w - tmp_f;
131 d->z = *((float*) &tmp_d);
132 d->w = 1.0f;
133 VSTRACE(("executing exp: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
134 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
135 }
136
137 void vshader_lit(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
138 d->x = 1.0f;
139 d->y = (0.0f < s0->x) ? s0->x : 0.0f;
140 d->z = (0.0f < s0->x && 0.0f < s0->y) ? powf(s0->y, s0->w) : 0.0f;
141 d->w = 1.0f;
142 VSTRACE(("executing lit: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
143 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
144 }
145
146 void vshader_logp(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
147 float tmp_f = fabsf(s0->w);
148 d->x = d->y = d->z = d->w = (0.0f != tmp_f) ? logf(tmp_f) / logf(2.0f) : -HUGE;
149 VSTRACE(("executing logp: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
150 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
151 }
152
153 void vshader_mad(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1, D3DSHADERVECTOR* s2) {
154 d->x = s0->x * s1->x + s2->x;
155 d->y = s0->y * s1->y + s2->y;
156 d->z = s0->z * s1->z + s2->z;
157 d->w = s0->w * s1->w + s2->w;
158 VSTRACE(("executing mad: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) s2=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
159 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));
160 }
161
162 void vshader_max(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
163 d->x = (s0->x >= s1->x) ? s0->x : s1->x;
164 d->y = (s0->y >= s1->y) ? s0->y : s1->y;
165 d->z = (s0->z >= s1->z) ? s0->z : s1->z;
166 d->w = (s0->w >= s1->w) ? s0->w : s1->w;
167 VSTRACE(("executing max: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
168 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
169 }
170
171 void vshader_min(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
172 d->x = (s0->x < s1->x) ? s0->x : s1->x;
173 d->y = (s0->y < s1->y) ? s0->y : s1->y;
174 d->z = (s0->z < s1->z) ? s0->z : s1->z;
175 d->w = (s0->w < s1->w) ? s0->w : s1->w;
176 VSTRACE(("executing min: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
177 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
178 }
179
180 void vshader_mov(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
181 d->x = s0->x;
182 d->y = s0->y;
183 d->z = s0->z;
184 d->w = s0->w;
185 VSTRACE(("executing mov: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
186 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
187 }
188
189 void vshader_mul(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
190 d->x = s0->x * s1->x;
191 d->y = s0->y * s1->y;
192 d->z = s0->z * s1->z;
193 d->w = s0->w * s1->w;
194 VSTRACE(("executing mul: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
195 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
196 }
197
198 void vshader_nop(void) {
199 /* NOPPPP ahhh too easy ;) */
200 }
201
202 void vshader_rcp(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
203 d->x = d->y = d->z = d->w = (0.0f == s0->w) ? HUGE : 1.0f / s0->w;
204 VSTRACE(("executing rcp: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
205 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
206 }
207
208 void vshader_rsq(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
209 float tmp_f = fabsf(s0->w);
210 d->x = d->y = d->z = d->w = (0.0f == tmp_f) ? HUGE : ((1.0f != tmp_f) ? 1.0f / sqrtf(tmp_f) : 1.0f);
211 VSTRACE(("executing rsq: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
212 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
213 }
214
215 void vshader_sge(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
216 d->x = (s0->x >= s1->x) ? 1.0f : 0.0f;
217 d->y = (s0->y >= s1->y) ? 1.0f : 0.0f;
218 d->z = (s0->z >= s1->z) ? 1.0f : 0.0f;
219 d->w = (s0->w >= s1->w) ? 1.0f : 0.0f;
220 VSTRACE(("executing sge: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
221 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
222 }
223
224 void vshader_slt(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
225 d->x = (s0->x < s1->x) ? 1.0f : 0.0f;
226 d->y = (s0->y < s1->y) ? 1.0f : 0.0f;
227 d->z = (s0->z < s1->z) ? 1.0f : 0.0f;
228 d->w = (s0->w < s1->w) ? 1.0f : 0.0f;
229 VSTRACE(("executing slt: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
230 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
231 }
232
233 void vshader_sub(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
234 d->x = s0->x - s1->x;
235 d->y = s0->y - s1->y;
236 d->z = s0->z - s1->z;
237 d->w = s0->w - s1->w;
238 VSTRACE(("executing sub: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
239 s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
240 }
241
242 /**
243 * Version 1.1 specific
244 */
245
246 void vshader_exp(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
247 d->x = d->y = d->z = d->w = powf(2.0f, s0->w);
248 VSTRACE(("executing exp: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
249 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
250 }
251
252 void vshader_log(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
253 float tmp_f = fabsf(s0->w);
254 d->x = d->y = d->z = d->w = (0.0f != tmp_f) ? logf(tmp_f) / logf(2.0f) : -HUGE;
255 VSTRACE(("executing log: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
256 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
257 }
258
259 void vshader_frc(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
260 d->x = s0->x - floorf(s0->x);
261 d->y = s0->y - floorf(s0->y);
262 d->z = 0.0f;
263 d->w = 1.0f;
264 VSTRACE(("executing frc: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
265 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
266 }
267
268 typedef FLOAT D3DMATRIX44[4][4];
269 typedef FLOAT D3DMATRIX43[4][3];
270 typedef FLOAT D3DMATRIX34[4][4];
271 typedef FLOAT D3DMATRIX33[4][3];
272 typedef FLOAT D3DMATRIX32[4][2];
273
274 void vshader_m4x4(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, /*D3DSHADERVECTOR* mat1*/ D3DMATRIX44 mat) {
275 /*
276 * BuGGY CODE: here only if cast not work for copy/paste
277 D3DSHADERVECTOR* mat2 = mat1 + 1;
278 D3DSHADERVECTOR* mat3 = mat1 + 2;
279 D3DSHADERVECTOR* mat4 = mat1 + 3;
280 d->x = mat1->x * s0->x + mat2->x * s0->y + mat3->x * s0->z + mat4->x * s0->w;
281 d->y = mat1->y * s0->x + mat2->y * s0->y + mat3->y * s0->z + mat4->y * s0->w;
282 d->z = mat1->z * s0->x + mat2->z * s0->y + mat3->z * s0->z + mat4->z * s0->w;
283 d->w = mat1->w * s0->x + mat2->w * s0->y + mat3->w * s0->z + mat4->w * s0->w;
284 */
285 d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z + mat[0][3] * s0->w;
286 d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z + mat[1][3] * s0->w;
287 d->z = mat[2][0] * s0->x + mat[2][1] * s0->y + mat[2][2] * s0->z + mat[2][3] * s0->w;
288 d->w = mat[3][0] * s0->x + mat[3][1] * s0->y + mat[3][2] * s0->z + mat[3][3] * s0->w;
289 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));
290 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));
291 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));
292 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));
293 }
294
295 void vshader_m4x3(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DMATRIX43 mat) {
296 d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z + mat[0][3] * s0->w;
297 d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z + mat[1][3] * s0->w;
298 d->z = mat[2][0] * s0->x + mat[2][1] * s0->y + mat[2][2] * s0->z + mat[2][3] * s0->w;
299 d->w = 1.0f;
300 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));
301 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));
302 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));
303 VSTRACE(("executing m4x3(4): (%f) (%f) \n", s0->w, d->w));
304 }
305
306 void vshader_m3x4(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DMATRIX34 mat) {
307 d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z;
308 d->y = mat[2][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z;
309 d->z = mat[2][0] * s0->x + mat[2][1] * s0->y + mat[2][2] * s0->z;
310 d->w = mat[3][0] * s0->x + mat[3][1] * s0->y + mat[3][2] * s0->z;
311 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));
312 VSTRACE(("executing m3x4(2): mat=(%f, %f, %f) (%f) (%f) \n", mat[1][0], mat[1][1], mat[1][2], s0->y, d->y));
313 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));
314 VSTRACE(("executing m3x4(4): mat=(%f, %f, %f) (%f) (%f) \n", mat[3][0], mat[3][1], mat[3][2], s0->w, d->w));
315 }
316
317 void vshader_m3x3(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DMATRIX33 mat) {
318 d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[2][2] * s0->z;
319 d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[2][2] * s0->z;
320 d->z = mat[2][0] * s0->x + mat[2][1] * s0->y + mat[2][2] * s0->z;
321 d->w = 1.0f;
322 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));
323 VSTRACE(("executing m3x3(2): mat=(%f, %f, %f) (%f) (%f) \n", mat[1][0], mat[1][1], mat[1][2], s0->y, d->y));
324 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));
325 VSTRACE(("executing m3x3(4): (%f) \n", d->w));
326 }
327
328 void vshader_m3x2(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DMATRIX32 mat) {
329 FIXME("check\n");
330 d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z;
331 d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z;
332 d->z = 0.0f;
333 d->w = 1.0f;
334 }
335
336 /**
337 * Version 2.0 specific
338 */
339 void vshader_lrp(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1, D3DSHADERVECTOR* s2, D3DSHADERVECTOR* s3) {
340 d->x = s0->x * (s1->x - s2->x) + s2->x;
341 d->y = s0->y * (s1->y - s2->y) + s2->y;
342 d->z = s0->z * (s1->z - s2->z) + s2->z;
343 d->w = s0->w * (s1->w - s2->w) + s2->x;
344 }
345
346 /**
347 * log, exp, frc, m*x* seems to be macros ins ... to see
348 */
349 static CONST SHADER_OPCODE vshader_ins [] = {
350 {D3DSIO_NOP, "nop", 0, vshader_nop, 0, 0},
351 {D3DSIO_MOV, "mov", 2, vshader_mov, 0, 0},
352 {D3DSIO_ADD, "add", 3, vshader_add, 0, 0},
353 {D3DSIO_SUB, "sub", 3, vshader_sub, 0, 0},
354 {D3DSIO_MAD, "mad", 4, vshader_mad, 0, 0},
355 {D3DSIO_MUL, "mul", 3, vshader_mul, 0, 0},
356 {D3DSIO_RCP, "rcp", 2, vshader_rcp, 0, 0},
357 {D3DSIO_RSQ, "rsq", 2, vshader_rsq, 0, 0},
358 {D3DSIO_DP3, "dp3", 3, vshader_dp3, 0, 0},
359 {D3DSIO_DP4, "dp4", 3, vshader_dp4, 0, 0},
360 {D3DSIO_MIN, "min", 3, vshader_min, 0, 0},
361 {D3DSIO_MAX, "max", 3, vshader_max, 0, 0},
362 {D3DSIO_SLT, "slt", 3, vshader_slt, 0, 0},
363 {D3DSIO_SGE, "sge", 3, vshader_sge, 0, 0},
364 {D3DSIO_EXP, "exp", 2, vshader_exp, 0, 0},
365 {D3DSIO_LOG, "log", 2, vshader_log, 0, 0},
366 {D3DSIO_LIT, "lit", 2, vshader_lit, 0, 0},
367 {D3DSIO_DST, "dst", 3, vshader_dst, 0, 0},
368 {D3DSIO_LRP, "lrp", 5, vshader_lrp, 0, 0},
369 {D3DSIO_FRC, "frc", 2, vshader_frc, 0, 0},
370 {D3DSIO_M4x4, "m4x4", 3, vshader_m4x4, 0, 0},
371 {D3DSIO_M4x3, "m4x3", 3, vshader_m4x3, 0, 0},
372 {D3DSIO_M3x4, "m3x4", 3, vshader_m3x4, 0, 0},
373 {D3DSIO_M3x3, "m3x3", 3, vshader_m3x3, 0, 0},
374 {D3DSIO_M3x2, "m3x2", 3, vshader_m3x2, 0, 0},
375 /** FIXME: use direct access so add the others opcodes as stubs */
376 {D3DSIO_EXPP, "expp", 2, vshader_expp, 0, 0},
377 {D3DSIO_LOGP, "logp", 2, vshader_logp, 0, 0},
378
379 {0, NULL, 0, NULL, 0, 0}
380 };
381
382
383 inline static const SHADER_OPCODE* vshader_program_get_opcode(const DWORD code) {
384 DWORD i = 0;
385 /** TODO: use dichotomic search */
386 while (NULL != vshader_ins[i].name) {
387 if ((code & D3DSI_OPCODE_MASK) == vshader_ins[i].opcode) {
388 return &vshader_ins[i];
389 }
390 ++i;
391 }
392 return NULL;
393 }
394
395 inline static void vshader_program_dump_param(const DWORD param, int input) {
396 static const char* rastout_reg_names[] = { "oPos", "oFog", "oPts" };
397 static const char swizzle_reg_chars[] = "xyzw";
398
399 DWORD reg = param & 0x00001FFF;
400 DWORD regtype = ((param & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT);
401
402 if ((param & D3DSP_SRCMOD_MASK) == D3DSPSM_NEG) TRACE("-");
403
404 switch (regtype << D3DSP_REGTYPE_SHIFT) {
405 case D3DSPR_TEMP:
406 TRACE("R[%lu]", reg);
407 break;
408 case D3DSPR_INPUT:
409 TRACE("V[%lu]", reg);
410 break;
411 case D3DSPR_CONST:
412 TRACE("C[%s%lu]", (reg & D3DVS_ADDRMODE_RELATIVE) ? "a0.x + " : "", reg);
413 break;
414 case D3DSPR_ADDR: /*case D3DSPR_TEXTURE:*/
415 TRACE("a[%lu]", reg);
416 break;
417 case D3DSPR_RASTOUT:
418 TRACE("%s", rastout_reg_names[reg]);
419 break;
420 case D3DSPR_ATTROUT:
421 TRACE("oD[%lu]", reg);
422 break;
423 case D3DSPR_TEXCRDOUT:
424 TRACE("oT[%lu]", reg);
425 break;
426 default:
427 break;
428 }
429
430 if (!input) {
431 /** operand output */
432 if ((param & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
433 if (param & D3DSP_WRITEMASK_0) TRACE(".x");
434 if (param & D3DSP_WRITEMASK_1) TRACE(".y");
435 if (param & D3DSP_WRITEMASK_2) TRACE(".z");
436 if (param & D3DSP_WRITEMASK_3) TRACE(".w");
437 }
438 } else {
439 /** operand input */
440 DWORD swizzle = (param & D3DVS_SWIZZLE_MASK) >> D3DVS_SWIZZLE_SHIFT;
441 DWORD swizzle_x = swizzle & 0x03;
442 DWORD swizzle_y = (swizzle >> 2) & 0x03;
443 DWORD swizzle_z = (swizzle >> 4) & 0x03;
444 DWORD swizzle_w = (swizzle >> 6) & 0x03;
445 /**
446 * swizzle bits fields:
447 * WWZZYYXX
448 */
449 if ((D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) != swizzle) { /* ! D3DVS_NOSWIZZLE == 0xE4 << D3DVS_SWIZZLE_SHIFT */
450 if (swizzle_x == swizzle_y &&
451 swizzle_x == swizzle_z &&
452 swizzle_x == swizzle_w) {
453 TRACE(".%c", swizzle_reg_chars[swizzle_x]);
454 } else {
455 TRACE(".%c%c%c%c",
456 swizzle_reg_chars[swizzle_x],
457 swizzle_reg_chars[swizzle_y],
458 swizzle_reg_chars[swizzle_z],
459 swizzle_reg_chars[swizzle_w]);
460 }
461 }
462 }
463 }
464
465 inline static BOOL vshader_is_version_token(DWORD token) {
466 return 0xFFFE0000 == (token & 0xFFFE0000);
467 }
468
469 inline static BOOL vshader_is_comment_token(DWORD token) {
470 return D3DSIO_COMMENT == (token & D3DSI_OPCODE_MASK);
471 }
472
473 /**
474 * Function parser ...
475 */
476 inline static VOID IDirect3DVertexShaderImpl_ParseProgram(IDirect3DVertexShaderImpl* vshader, CONST DWORD* pFunction) {
477 const DWORD* pToken = pFunction;
478 const SHADER_OPCODE* curOpcode = NULL;
479 DWORD len = 0;
480 DWORD i;
481
482 if (NULL != pToken) {
483 while (D3DVS_END() != *pToken) {
484 if (vshader_is_version_token(*pToken)) { /** version */
485 TRACE("vs.%lu.%lu\n", (*pToken >> 8) & 0x0F, (*pToken & 0x0F));
486 ++pToken;
487 ++len;
488 continue;
489 }
490 if (vshader_is_comment_token(*pToken)) { /** comment */
491 DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
492 ++pToken;
493 /*TRACE("comment[%ld] ;%s\n", comment_len, (char*)pToken);*/
494 pToken += comment_len;
495 len += comment_len + 1;
496 continue;
497 }
498 curOpcode = vshader_program_get_opcode(*pToken);
499 ++pToken;
500 ++len;
501 if (NULL == curOpcode) {
502 /* unkown current opcode ... */
503 while (*pToken & 0x80000000) {
504 TRACE("unrecognized opcode: %08lx\n", *pToken);
505 ++pToken;
506 ++len;
507 }
508 } else {
509 TRACE("%s ", curOpcode->name);
510 if (curOpcode->num_params > 0) {
511 vshader_program_dump_param(*pToken, 0);
512 ++pToken;
513 ++len;
514 for (i = 1; i < curOpcode->num_params; ++i) {
515 TRACE(", ");
516 vshader_program_dump_param(*pToken, 1);
517 ++pToken;
518 ++len;
519 }
520 }
521 TRACE("\n");
522 }
523 }
524 vshader->functionLength = (len + 1) * sizeof(DWORD);
525 } else {
526 vshader->functionLength = 1; /* no Function defined use fixed function vertex processing */
527 }
528 /* copy the function ... because it will certainly be released by application */
529
530 if (NULL != pFunction) {
531 vshader->function = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, vshader->functionLength);
532 memcpy(vshader->function, pFunction, vshader->functionLength);
533 } else {
534 vshader->function = NULL;
535 }
536 }
537
538 HRESULT WINAPI IDirect3DDeviceImpl_CreateVertexShader(IDirect3DDevice8Impl* This, CONST DWORD* pFunction, DWORD Usage, IDirect3DVertexShaderImpl** ppVertexShader) {
539 IDirect3DVertexShaderImpl* object;
540
541 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DVertexShaderImpl));
542 if (NULL == object) {
543 *ppVertexShader = NULL;
544 return D3DERR_OUTOFVIDEOMEMORY;
545 }
546 /*object->lpVtbl = &Direct3DVextexShader9_Vtbl;*/
547 object->device = This; /* FIXME: AddRef(This) */
548 object->ref = 1;
549
550 object->usage = Usage;
551 object->data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(VSHADERDATA8));
552
553 IDirect3DVertexShaderImpl_ParseProgram(object, pFunction);
554
555 *ppVertexShader = object;
556 return D3D_OK;
557 }
558
559 BOOL IDirect3DVertexShaderImpl_ExecuteHAL(IDirect3DVertexShaderImpl* vshader, VSHADERINPUTDATA8* input, VSHADEROUTPUTDATA8* output) {
560 /**
561 * TODO: use the NV_vertex_program (or 1_1) extension
562 * and specifics vendors (ARB_vertex_program??) variants for it
563 */
564 return TRUE;
565 }
566
567 HRESULT WINAPI IDirect3DVertexShaderImpl_ExecuteSW(IDirect3DVertexShaderImpl* vshader, VSHADERINPUTDATA8* input, VSHADEROUTPUTDATA8* output) {
568 /** Vertex Shader Temporary Registers */
569 D3DSHADERVECTOR R[12];
570 /*D3DSHADERSCALAR A0;*/
571 D3DSHADERVECTOR A[1];
572 /** temporary Vector for modifier management */
573 D3DSHADERVECTOR d;
574 D3DSHADERVECTOR s[3];
575 /** parser datas */
576 const DWORD* pToken = vshader->function;
577 const SHADER_OPCODE* curOpcode = NULL;
578 /** functions parameters */
579 D3DSHADERVECTOR* p[4];
580 D3DSHADERVECTOR* p_send[4];
581 DWORD i;
582
583 /** init temporary register */
584 memset(R, 0, 12 * sizeof(D3DSHADERVECTOR));
585
586 /* vshader_program_parse(vshader); */
587 #if 0 /* Must not be 1 in cvs */
588 TRACE("Input:\n");
589 TRACE_VSVECTOR(vshader->data->C[0]);
590 TRACE_VSVECTOR(vshader->data->C[1]);
591 TRACE_VSVECTOR(vshader->data->C[2]);
592 TRACE_VSVECTOR(vshader->data->C[3]);
593 TRACE_VSVECTOR(vshader->data->C[4]);
594 TRACE_VSVECTOR(vshader->data->C[5]);
595 TRACE_VSVECTOR(vshader->data->C[6]);
596 TRACE_VSVECTOR(vshader->data->C[7]);
597 TRACE_VSVECTOR(vshader->data->C[8]);
598 TRACE_VSVECTOR(vshader->data->C[64]);
599 TRACE_VSVECTOR(input->V[D3DVSDE_POSITION]);
600 TRACE_VSVECTOR(input->V[D3DVSDE_BLENDWEIGHT]);
601 TRACE_VSVECTOR(input->V[D3DVSDE_BLENDINDICES]);
602 TRACE_VSVECTOR(input->V[D3DVSDE_NORMAL]);
603 TRACE_VSVECTOR(input->V[D3DVSDE_PSIZE]);
604 TRACE_VSVECTOR(input->V[D3DVSDE_DIFFUSE]);
605 TRACE_VSVECTOR(input->V[D3DVSDE_SPECULAR]);
606 TRACE_VSVECTOR(input->V[D3DVSDE_TEXCOORD0]);
607 TRACE_VSVECTOR(input->V[D3DVSDE_TEXCOORD1]);
608 #endif
609
610 TRACE_VSVECTOR(vshader->data->C[64]);
611
612 /* the first dword is the version tag */
613 /* TODO: parse it */
614
615 if (vshader_is_version_token(*pToken)) { /** version */
616 ++pToken;
617 }
618 while (D3DVS_END() != *pToken) {
619 if (vshader_is_comment_token(*pToken)) { /** comment */
620 DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
621 ++pToken;
622 pToken += comment_len;
623 continue ;
624 }
625 curOpcode = vshader_program_get_opcode(*pToken);
626 ++pToken;
627 if (NULL == curOpcode) {
628 i = 0;
629 /* unkown current opcode ... */
630 while (*pToken & 0x80000000) {
631 if (i == 0) {
632 TRACE("unrecognized opcode: pos=%d token=%08lX\n", (pToken - 1) - vshader->function, *(pToken - 1));
633 }
634 TRACE("unrecognized opcode param: pos=%d token=%08lX what=", pToken - vshader->function, *pToken);
635 vshader_program_dump_param(*pToken, i);
636 TRACE("\n");
637 ++i;
638 ++pToken;
639 }
640 /*return FALSE;*/
641 } else {
642 if (curOpcode->num_params > 0) {
643 /*TRACE(">> execting opcode: pos=%d opcode_name=%s token=%08lX\n", pToken - vshader->function, curOpcode->name, *pToken);*/
644 for (i = 0; i < curOpcode->num_params; ++i) {
645 DWORD reg = pToken[i] & 0x00001FFF;
646 DWORD regtype = ((pToken[i] & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT);
647
648 switch (regtype << D3DSP_REGTYPE_SHIFT) {
649 case D3DSPR_TEMP:
650 /*TRACE("p[%d]=R[%d]\n", i, reg);*/
651 p[i] = &R[reg];
652 break;
653 case D3DSPR_INPUT:
654 /*TRACE("p[%d]=V[%s]\n", i, VertexShaderDeclRegister[reg]);*/
655 p[i] = &input->V[reg];
656 break;
657 case D3DSPR_CONST:
658 if (reg & D3DVS_ADDRMODE_RELATIVE) {
659 p[i] = &vshader->data->C[(DWORD) A[0].x + reg];
660 } else {
661 p[i] = &vshader->data->C[reg];
662 }
663 break;
664 case D3DSPR_ADDR: /*case D3DSPR_TEXTURE:*/
665 if (0 != reg) {
666 ERR("cannot handle address registers != a0, forcing use of a0\n");
667 reg = 0;
668 }
669 /*TRACE("p[%d]=A[%d]\n", i, reg);*/
670 p[i] = &A[reg];
671 break;
672 case D3DSPR_RASTOUT:
673 switch (reg) {
674 case D3DSRO_POSITION:
675 p[i] = &output->oPos;
676 break;
677 case D3DSRO_FOG:
678 p[i] = &output->oFog;
679 break;
680 case D3DSRO_POINT_SIZE:
681 p[i] = &output->oPts;
682 break;
683 }
684 break;
685 case D3DSPR_ATTROUT:
686 /*TRACE("p[%d]=oD[%d]\n", i, reg);*/
687 p[i] = &output->oD[reg];
688 break;
689 case D3DSPR_TEXCRDOUT:
690 /*TRACE("p[%d]=oT[%d]\n", i, reg);*/
691 p[i] = &output->oT[reg];
692 break;
693 default:
694 break;
695 }
696
697 if (i > 0) { /* input reg */
698 DWORD swizzle = (pToken[i] & D3DVS_SWIZZLE_MASK) >> D3DVS_SWIZZLE_SHIFT;
699 UINT isNegative = ((pToken[i] & D3DSP_SRCMOD_MASK) == D3DSPSM_NEG);
700
701 if (!isNegative && (D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) == swizzle) {
702 /*TRACE("p[%d] not swizzled\n", i);*/
703 p_send[i] = p[i];
704 } else {
705 DWORD swizzle_x = swizzle & 0x03;
706 DWORD swizzle_y = (swizzle >> 2) & 0x03;
707 DWORD swizzle_z = (swizzle >> 4) & 0x03;
708 DWORD swizzle_w = (swizzle >> 6) & 0x03;
709 /*TRACE("p[%d] swizzled\n", i);*/
710 float* tt = (float*) p[i];
711 s[i].x = (isNegative) ? -tt[swizzle_x] : tt[swizzle_x];
712 s[i].y = (isNegative) ? -tt[swizzle_y] : tt[swizzle_y];
713 s[i].z = (isNegative) ? -tt[swizzle_z] : tt[swizzle_z];
714 s[i].w = (isNegative) ? -tt[swizzle_w] : tt[swizzle_w];
715 p_send[i] = &s[i];
716 }
717 } else { /* output reg */
718 if ((pToken[i] & D3DSP_WRITEMASK_ALL) == D3DSP_WRITEMASK_ALL) {
719 p_send[i] = p[i];
720 } else {
721 p_send[i] = &d; /* to be post-processed for modifiers management */
722 }
723 }
724 }
725 }
726
727 switch (curOpcode->num_params) {
728 case 0:
729 curOpcode->soft_fct();
730 break;
731 case 1:
732 curOpcode->soft_fct(p_send[0]);
733 break;
734 case 2:
735 curOpcode->soft_fct(p_send[0], p_send[1]);
736 break;
737 case 3:
738 curOpcode->soft_fct(p_send[0], p_send[1], p_send[2]);
739 break;
740 case 4:
741 curOpcode->soft_fct(p_send[0], p_send[1], p_send[2], p_send[3]);
742 break;
743 case 5:
744 curOpcode->soft_fct(p_send[0], p_send[1], p_send[2], p_send[3], p_send[4]);
745 break;
746 default:
747 ERR("%s too many params: %u\n", curOpcode->name, curOpcode->num_params);
748 }
749
750 /* check if output reg modifier post-process */
751 if (curOpcode->num_params > 0 && (pToken[0] & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
752 if (pToken[0] & D3DSP_WRITEMASK_0) p[0]->x = d.x;
753 if (pToken[0] & D3DSP_WRITEMASK_1) p[0]->y = d.y;
754 if (pToken[0] & D3DSP_WRITEMASK_2) p[0]->z = d.z;
755 if (pToken[0] & D3DSP_WRITEMASK_3) p[0]->w = d.w;
756 }
757
758 #if 0
759 TRACE_VSVECTOR(output->oPos);
760 TRACE_VSVECTOR(output->oD[0]);
761 TRACE_VSVECTOR(output->oD[1]);
762 TRACE_VSVECTOR(output->oT[0]);
763 TRACE_VSVECTOR(output->oT[1]);
764 TRACE_VSVECTOR(R[0]);
765 TRACE_VSVECTOR(R[1]);
766 TRACE_VSVECTOR(R[2]);
767 TRACE_VSVECTOR(R[3]);
768 TRACE_VSVECTOR(R[4]);
769 TRACE_VSVECTOR(R[5]);
770 #endif
771
772 /* to next opcode token */
773 pToken += curOpcode->num_params;
774 }
775 #if 0
776 TRACE("End of current instruction:\n");
777 TRACE_VSVECTOR(output->oPos);
778 TRACE_VSVECTOR(output->oD[0]);
779 TRACE_VSVECTOR(output->oD[1]);
780 TRACE_VSVECTOR(output->oT[0]);
781 TRACE_VSVECTOR(output->oT[1]);
782 TRACE_VSVECTOR(R[0]);
783 TRACE_VSVECTOR(R[1]);
784 TRACE_VSVECTOR(R[2]);
785 TRACE_VSVECTOR(R[3]);
786 TRACE_VSVECTOR(R[4]);
787 TRACE_VSVECTOR(R[5]);
788 #endif
789 }
790 #if 0 /* Must not be 1 in cvs */
791 TRACE("Output:\n");
792 TRACE_VSVECTOR(output->oPos);
793 TRACE_VSVECTOR(output->oD[0]);
794 TRACE_VSVECTOR(output->oD[1]);
795 TRACE_VSVECTOR(output->oT[0]);
796 TRACE_VSVECTOR(output->oT[1]);
797 #endif
798 return D3D_OK;
799 }
800
801 HRESULT WINAPI IDirect3DVertexShaderImpl_GetFunction(IDirect3DVertexShaderImpl* This, VOID* pData, UINT* pSizeOfData) {
802 if (NULL == pData) {
803 *pSizeOfData = This->functionLength;
804 return D3D_OK;
805 }
806 if (*pSizeOfData < This->functionLength) {
807 *pSizeOfData = This->functionLength;
808 return D3DERR_MOREDATA;
809 }
810 if (NULL == This->function) { /* no function defined */
811 TRACE("(%p) : GetFunction no User Function defined using NULL to %p\n", This, pData);
812 (*(DWORD **) pData) = NULL;
813 } else {
814 TRACE("(%p) : GetFunction copying to %p\n", This, pData);
815 memcpy(pData, This->function, This->functionLength);
816 }
817 return D3D_OK;
818 }
819
820 HRESULT WINAPI IDirect3DVertexShaderImpl_SetConstantF(IDirect3DVertexShaderImpl* This, UINT StartRegister, CONST FLOAT* pConstantData, UINT Vector4fCount) {
821 if (StartRegister + Vector4fCount > D3D8_VSHADER_MAX_CONSTANTS) {
822 return D3DERR_INVALIDCALL;
823 }
824 if (NULL == This->data) { /* temporary while datas not supported */
825 FIXME("(%p) : VertexShader_SetConstant not fully supported yet\n", This);
826 return D3DERR_INVALIDCALL;
827 }
828 memcpy(&This->data->C[StartRegister], pConstantData, Vector4fCount * 4 * sizeof(FLOAT));
829 return D3D_OK;
830 }
831
832 HRESULT WINAPI IDirect3DVertexShaderImpl_GetConstantF(IDirect3DVertexShaderImpl* This, UINT StartRegister, FLOAT* pConstantData, UINT Vector4fCount) {
833 if (StartRegister + Vector4fCount > D3D8_VSHADER_MAX_CONSTANTS) {
834 return D3DERR_INVALIDCALL;
835 }
836 if (NULL == This->data) { /* temporary while datas not supported */
837 return D3DERR_INVALIDCALL;
838 }
839 memcpy(pConstantData, &This->data->C[StartRegister], Vector4fCount * 4 * sizeof(FLOAT));
840 return D3D_OK;
841 }
842
843
844 /**********************************************************************************************************************************************
845 **********************************************************************************************************************************************
846 **********************************************************************************************************************************************
847 **********************************************************************************************************************************************
848 **********************************************************************************************************************************************/
849
850 void pshader_texcoord(D3DSHADERVECTOR* d) {
851 }
852
853 void pshader_texkill(D3DSHADERVECTOR* d) {
854 }
855
856 void pshader_tex(D3DSHADERVECTOR* d) {
857 }
858
859 void pshader_texbem(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
860 }
861
862 void pshader_texbeml(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
863 }
864
865 void pshader_texreg2ar(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
866 }
867
868 void pshader_texreg2gb(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
869 }
870
871 void pshader_texm3x2pad(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
872 }
873
874 void pshader_texm3x2tex(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
875 }
876
877 void pshader_texm3x3pad(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
878 }
879
880 void pshader_texm3x3tex(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
881 }
882
883 void pshader_texm3x3diff(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
884 }
885
886 void pshader_texm3x3spec(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
887 }
888
889 void pshader_texm3x3vspec(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
890 }
891
892 void pshader_cnd(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1, D3DSHADERVECTOR* s2) {
893 }
894
895 void pshader_def(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1, D3DSHADERVECTOR* s2, D3DSHADERVECTOR* s3) {
896 }
897
898 void pshader_texreg2rgb(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
899 }
900
901 void pshader_texdp3tex(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
902 }
903
904 void pshader_texm3x2depth(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
905 }
906
907 void pshader_texdp3(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
908 }
909
910 void pshader_texm3x3(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
911 }
912
913 void pshader_texdepth(D3DSHADERVECTOR* d) {
914 }
915
916 void pshader_cmp(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1, D3DSHADERVECTOR* s2) {
917 }
918
919 void pshader_bem(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
920 }
921
922 static CONST SHADER_OPCODE pshader_ins [] = {
923 {D3DSIO_NOP, "nop", 0, vshader_nop, 0, 0},
924 {D3DSIO_MOV, "mov", 2, vshader_mov, 0, 0},
925 {D3DSIO_ADD, "add", 3, vshader_add, 0, 0},
926 {D3DSIO_SUB, "sub", 3, vshader_sub, 0, 0},
927 {D3DSIO_MAD, "mad", 4, vshader_mad, 0, 0},
928 {D3DSIO_MUL, "mul", 3, vshader_mul, 0, 0},
929 {D3DSIO_RCP, "rcp", 2, vshader_rcp, 0, 0},
930 {D3DSIO_RSQ, "rsq", 2, vshader_rsq, 0, 0},
931 {D3DSIO_DP3, "dp3", 3, vshader_dp3, 0, 0},
932 {D3DSIO_DP4, "dp4", 3, vshader_dp4, 0, 0},
933 {D3DSIO_MIN, "min", 3, vshader_min, 0, 0},
934 {D3DSIO_MAX, "max", 3, vshader_max, 0, 0},
935 {D3DSIO_SLT, "slt", 3, vshader_slt, 0, 0},
936 {D3DSIO_SGE, "sge", 3, vshader_sge, 0, 0},
937 {D3DSIO_EXP, "exp", 2, vshader_exp, 0, 0},
938 {D3DSIO_LOG, "log", 2, vshader_log, 0, 0},
939 {D3DSIO_LIT, "lit", 2, vshader_lit, 0, 0},
940 {D3DSIO_DST, "dst", 3, vshader_dst, 0, 0},
941 {D3DSIO_LRP, "lrp", 5, vshader_lrp, 0, 0},
942 {D3DSIO_FRC, "frc", 2, vshader_frc, 0, 0},
943 {D3DSIO_M4x4, "m4x4", 3, vshader_m4x4, 0, 0},
944 {D3DSIO_M4x3, "m4x3", 3, vshader_m4x3, 0, 0},
945 {D3DSIO_M3x4, "m3x4", 3, vshader_m3x4, 0, 0},
946 {D3DSIO_M3x3, "m3x3", 3, vshader_m3x3, 0, 0},
947 {D3DSIO_M3x2, "m3x2", 3, vshader_m3x2, 0, 0},
948
949 {D3DSIO_TEXCOORD, "texcoord", 1, pshader_texcoord, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
950 {D3DSIO_TEXKILL, "texkill", 1, pshader_texkill, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
951 {D3DSIO_TEX, "tex", 1, pshader_tex, D3DPS_VERSION(1,1), D3DPS_VERSION(1,4)},
952 {D3DSIO_TEXBEM, "texbem", 2, pshader_texbem, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
953 {D3DSIO_TEXBEML, "texbeml", 2, pshader_texbeml, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
954 {D3DSIO_TEXREG2AR, "texreg2ar", 2, pshader_texreg2ar, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
955 {D3DSIO_TEXREG2GB, "texreg2gb", 2, pshader_texreg2gb, D3DPS_VERSION(1,2), D3DPS_VERSION(1,3)},
956 {D3DSIO_TEXM3x2PAD, "texm3x2pad", 2, pshader_texm3x2pad, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
957 {D3DSIO_TEXM3x2TEX, "texm3x2tex", 2, pshader_texm3x2tex, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
958 {D3DSIO_TEXM3x3PAD, "texm3x3pad", 2, pshader_texm3x3pad, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
959 {D3DSIO_TEXM3x3TEX, "texm3x3tex", 2, pshader_texm3x3tex, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
960 {D3DSIO_TEXM3x3DIFF, "texm3x3diff", 2, pshader_texm3x3diff, D3DPS_VERSION(0,0), D3DPS_VERSION(0,0)},
961 {D3DSIO_TEXM3x3SPEC, "texm3x3spec", 3, pshader_texm3x3spec, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
962 {D3DSIO_TEXM3x3VSPEC, "texm3x3vspec", 2, pshader_texm3x3vspec, D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
963
964 {D3DSIO_EXPP, "expp", 2, vshader_expp, 0, 0},
965 {D3DSIO_LOGP, "logp", 2, vshader_logp, 0, 0},
966
967 {D3DSIO_CND, "cnd", 4, pshader_cnd, D3DPS_VERSION(1,1), D3DPS_VERSION(1,4)},
968 {D3DSIO_DEF, "def", 5, pshader_def, D3DPS_VERSION(1,1), D3DPS_VERSION(3,0)},
969 {D3DSIO_TEXREG2RGB, "texbreg2rgb", 2, pshader_texreg2rgb, D3DPS_VERSION(1,2), D3DPS_VERSION(1,3)},
970
971 {D3DSIO_TEXDP3TEX, "texdp3tex", 2, pshader_texdp3tex, D3DPS_VERSION(1,2), D3DPS_VERSION(1,3)},
972 {D3DSIO_TEXM3x2DEPTH, "texm3x2depth", 2, pshader_texm3x2depth, D3DPS_VERSION(1,3), D3DPS_VERSION(1,3)},
973 {D3DSIO_TEXDP3, "texdp3", 2, pshader_texdp3, D3DPS_VERSION(1,2), D3DPS_VERSION(1,3)},
974 {D3DSIO_TEXM3x3, "texm3x3", 2, pshader_texm3x3, D3DPS_VERSION(1,2), D3DPS_VERSION(1,3)},
975 {D3DSIO_TEXDEPTH, "texdepth", 1, pshader_texdepth, D3DPS_VERSION(1,4), D3DPS_VERSION(1,4)},
976 {D3DSIO_CMP, "cmp", 4, pshader_cmp, D3DPS_VERSION(1,1), D3DPS_VERSION(3,0)},
977 {D3DSIO_BEM, "bem", 3, pshader_bem, D3DPS_VERSION(1,4), D3DPS_VERSION(1,4)},
978
979 {0, NULL, 0, NULL}
980 };
981
982 inline static const SHADER_OPCODE* pshader_program_get_opcode(const DWORD code) {
983 DWORD i = 0;
984 /** TODO: use dichotomic search */
985 while (NULL != pshader_ins[i].name) {
986 if ((code & D3DSI_OPCODE_MASK) == pshader_ins[i].opcode) {
987 return &pshader_ins[i];
988 }
989 ++i;
990 }
991 return NULL;
992 }
993
994 inline static void pshader_program_dump_opcode(const SHADER_OPCODE* curOpcode, const DWORD code, const DWORD output) {
995 if (0 != (code & ~D3DSI_OPCODE_MASK)) {
996 DWORD mask = (code & ~D3DSI_OPCODE_MASK);
997 switch (mask) {
998 case 0x40000000: TRACE("+"); break;
999 default:
1000 TRACE(" unhandled modifier(0x%08lx) ", mask);
1001 }
1002 }
1003 TRACE("%s", curOpcode->name);
1004 /**
1005 * normally this is a destination reg modifier
1006 * but in pixel shaders asm code its specified as:
1007 * dp3_x4 t1.rgba, r1, c1
1008 * or
1009 * dp3_x2_sat r0, t0_bx2, v0_bx2
1010 * so for better debbuging i use the same norm
1011 */
1012 if (0 != (output & D3DSP_DSTSHIFT_MASK)) {
1013 DWORD shift = (output & D3DSP_DSTSHIFT_MASK) >> D3DSP_DSTSHIFT_SHIFT;
1014 if (shift > 0) {
1015 TRACE("_x%u", 1 << shift);
1016 }
1017 }
1018 /**
1019 * TODO: fix the divide shifts: d2, d4, d8
1020 * so i have to find a sample
1021 */
1022 if (0 != (output & D3DSP_DSTMOD_MASK)) {
1023 DWORD mask = output & D3DSP_DSTMOD_MASK;
1024 switch (mask) {
1025 case D3DSPDM_SATURATE: TRACE("_sat"); break;
1026 default:
1027 TRACE("_unhandled_modifier(0x%08lx)", mask);
1028 }
1029 }
1030 TRACE(" ");
1031 }
1032
1033 inline static void pshader_program_dump_param(const DWORD param, int input) {
1034 static const char* rastout_reg_names[] = { "oC0", "oC1", "oC2", "oC3", "oDepth" };
1035 static const char swizzle_reg_chars[] = "rgba";
1036
1037 DWORD reg = param & 0x00001FFF;
1038 DWORD regtype = ((param & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT);
1039
1040 if ((param & D3DSP_SRCMOD_MASK) == D3DSPSM_NEG) {
1041 TRACE("-");
1042 }
1043
1044 switch (regtype << D3DSP_REGTYPE_SHIFT) {
1045 case D3DSPR_TEMP:
1046 TRACE("R[%lu]", reg);
1047 break;
1048 case D3DSPR_INPUT:
1049 TRACE("V[%lu]", reg);
1050 break;
1051 case D3DSPR_CONST:
1052 TRACE("C[%s%lu]", (reg & D3DVS_ADDRMODE_RELATIVE) ? "a0.x + " : "", reg);
1053 break;
1054 case D3DSPR_TEXTURE: /* case D3DSPR_ADDR: */
1055 TRACE("t[%lu]", reg);
1056 break;
1057 case D3DSPR_RASTOUT:
1058 TRACE("%s", rastout_reg_names[reg]);
1059 break;
1060 case D3DSPR_ATTROUT:
1061 TRACE("oD[%lu]", reg);
1062 break;
1063 case D3DSPR_TEXCRDOUT:
1064 TRACE("oT[%lu]", reg);
1065 break;
1066 default:
1067 break;
1068 }
1069
1070 if (!input) {
1071 /** operand output */
1072 /**
1073 * for better debugging traces it's done into opcode dump code
1074 * @see pshader_program_dump_opcode
1075 if (0 != (param & D3DSP_DSTMOD_MASK)) {
1076 DWORD mask = param & D3DSP_DSTMOD_MASK;
1077 switch (mask) {
1078 case D3DSPDM_SATURATE: TRACE("_sat"); break;
1079 default:
1080 TRACE("_unhandled_modifier(0x%08lx)", mask);
1081 }
1082 }
1083 if (0 != (param & D3DSP_DSTSHIFT_MASK)) {
1084 DWORD shift = (param & D3DSP_DSTSHIFT_MASK) >> D3DSP_DSTSHIFT_SHIFT;
1085 if (shift > 0) {
1086 TRACE("_x%u", 1 << shift);
1087 }
1088 }
1089 */
1090 if ((param & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
1091 if (param & D3DSP_WRITEMASK_0) TRACE(".r");
1092 if (param & D3DSP_WRITEMASK_1) TRACE(".g");
1093 if (param & D3DSP_WRITEMASK_2) TRACE(".b");
1094 if (param & D3DSP_WRITEMASK_3) TRACE(".a");
1095 }
1096 } else {
1097 /** operand input */
1098 DWORD swizzle = (param & D3DSP_SWIZZLE_MASK) >> D3DSP_SWIZZLE_SHIFT;
1099 DWORD swizzle_x = swizzle & 0x03;
1100 DWORD swizzle_y = (swizzle >> 2) & 0x03;
1101 DWORD swizzle_z = (swizzle >> 4) & 0x03;
1102 DWORD swizzle_w = (swizzle >> 6) & 0x03;
1103 /**
1104 * swizzle bits fields:
1105 * WWZZYYXX
1106 */
1107 if ((D3DSP_NOSWIZZLE >> D3DSP_SWIZZLE_SHIFT) != swizzle) { /* ! D3DVS_NOSWIZZLE == 0xE4 << D3DVS_SWIZZLE_SHIFT */
1108 if (swizzle_x == swizzle_y &&
1109 swizzle_x == swizzle_z &&
1110 swizzle_x == swizzle_w) {
1111 TRACE(".%c", swizzle_reg_chars[swizzle_x]);
1112 } else {
1113 TRACE(".%c%c%c%c",
1114 swizzle_reg_chars[swizzle_x],
1115 swizzle_reg_chars[swizzle_y],
1116 swizzle_reg_chars[swizzle_z],
1117 swizzle_reg_chars[swizzle_w]);
1118 }
1119 }
1120 if (0 != (param & D3DSP_SRCMOD_MASK)) {
1121 DWORD mask = param & D3DSP_SRCMOD_MASK;
1122 /*TRACE("_modifier(0x%08lx) ", mask);*/
1123 switch (mask) {
1124 case D3DSPSM_NONE: break;
1125 case D3DSPSM_NEG: break;
1126 case D3DSPSM_BIAS: TRACE("_bias"); break;
1127 case D3DSPSM_BIASNEG: TRACE("_bias"); break;
1128 case D3DSPSM_SIGN: TRACE("_sign"); break;
1129 case D3DSPSM_SIGNNEG: TRACE("_sign"); break;
1130 case D3DSPSM_COMP: TRACE("_comp"); break;
1131 case D3DSPSM_X2: TRACE("_x2"); break;
1132 case D3DSPSM_X2NEG: TRACE("_bx2"); break;
1133 case D3DSPSM_DZ: TRACE("_dz"); break;
1134 case D3DSPSM_DW: TRACE("_dw"); break;
1135 default:
1136 TRACE("_unknown(0x%08lx)", mask);
1137 }
1138 }
1139 }
1140 }
1141
1142 inline static BOOL pshader_is_version_token(DWORD token) {
1143 return 0xFFFF0000 == (token & 0xFFFF0000);
1144 }
1145
1146 inline static BOOL pshader_is_comment_token(DWORD token) {
1147 return D3DSIO_COMMENT == (token & D3DSI_OPCODE_MASK);
1148 }
1149
1150
1151
1152 /**
1153 * Pixel Shaders
1154 *
1155 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/PixelShader1_X/modifiers/sourceregistermodifiers.asp
1156 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/PixelShader2_0/Registers/Registers.asp
1157 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/d3d/interfaces/IDirect3DPixelShader9/_IDirect3DPixelShader9.asp
1158 *
1159 */
1160 inline static VOID IDirect3DPixelShaderImpl_ParseProgram(IDirect3DPixelShaderImpl* pshader, CONST DWORD* pFunction) {
1161 const DWORD* pToken = pFunction;
1162 const SHADER_OPCODE* curOpcode = NULL;
1163 DWORD code;
1164 DWORD len = 0;
1165 DWORD i;
1166
1167 if (NULL != pToken) {
1168 while (D3DPS_END() != *pToken) {
1169 if (pshader_is_version_token(*pToken)) { /** version */
1170 TRACE("ps.%lu.%lu\n", (*pToken >> 8) & 0x0F, (*pToken & 0x0F));
1171 ++pToken;
1172 ++len;
1173 continue;
1174 }
1175 if (pshader_is_comment_token(*pToken)) { /** comment */
1176 DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
1177 ++pToken;
1178 /*TRACE("comment[%ld] ;%s\n", comment_len, (char*)pToken);*/
1179 pToken += comment_len;
1180 len += comment_len + 1;
1181 continue;
1182 }
1183 code = *pToken;
1184 curOpcode = pshader_program_get_opcode(code);
1185 ++pToken;
1186 ++len;
1187 if (NULL == curOpcode) {
1188 /* unkown current opcode ... */
1189 while (*pToken & 0x80000000) {
1190 TRACE("unrecognized opcode: %08lx\n", *pToken);
1191 ++pToken;
1192 ++len;
1193 }
1194 } else {
1195 TRACE(" ");
1196 pshader_program_dump_opcode(curOpcode, code, *pToken);
1197 if (curOpcode->num_params > 0) {
1198 pshader_program_dump_param(*pToken, 0);
1199 ++pToken;
1200 ++len;
1201 for (i = 1; i < curOpcode->num_params; ++i) {
1202 TRACE(", ");
1203 if (D3DSIO_DEF != code) {
1204 pshader_program_dump_param(*pToken, 1);
1205 } else {
1206 TRACE("%f", *((float*) pToken));
1207 }
1208 ++pToken;
1209 ++len;
1210 }
1211 }
1212 TRACE("\n");
1213 }
1214 pshader->functionLength = (len + 1) * sizeof(DWORD);
1215 }
1216 } else {
1217 pshader->functionLength = 1; /* no Function defined use fixed function vertex processing */
1218 }
1219 if (NULL != pFunction) {
1220 pshader->function = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, pshader->functionLength);
1221 memcpy(pshader->function, pFunction, pshader->functionLength);
1222 } else {
1223 pshader->function = NULL;
1224 }
1225 }
1226
1227 HRESULT WINAPI IDirect3DDeviceImpl_CreatePixelShader(IDirect3DDevice8Impl* This, CONST DWORD* pFunction, IDirect3DPixelShaderImpl** ppPixelShader) {
1228 IDirect3DPixelShaderImpl* object;
1229
1230 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DPixelShaderImpl));
1231 if (NULL == object) {
1232 *ppPixelShader = NULL;
1233 return D3DERR_OUTOFVIDEOMEMORY;
1234 }
1235 /*object->lpVtbl = &Direct3DPixelShader9_Vtbl;*/
1236 object->device = This;
1237 object->ref = 1;
1238
1239 object->data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PSHADERDATA8));
1240
1241 IDirect3DPixelShaderImpl_ParseProgram(object, pFunction);
1242
1243 *ppPixelShader = object;
1244 return D3D_OK;
1245 }
1246
1247 HRESULT WINAPI IDirect3DPixelShaderImpl_GetFunction(IDirect3DPixelShaderImpl* This, VOID* pData, UINT* pSizeOfData) {
1248 if (NULL == pData) {
1249 *pSizeOfData = This->functionLength;
1250 return D3D_OK;
1251 }
1252 if (*pSizeOfData < This->functionLength) {
1253 *pSizeOfData = This->functionLength;
1254 return D3DERR_MOREDATA;
1255 }
1256 if (NULL == This->function) { /* no function defined */
1257 TRACE("(%p) : GetFunction no User Function defined using NULL to %p\n", This, pData);
1258 (*(DWORD **) pData) = NULL;
1259 } else {
1260 TRACE("(%p) : GetFunction copying to %p\n", This, pData);
1261 memcpy(pData, This->function, This->functionLength);
1262 }
1263 return D3D_OK;
1264 }
1265
1266 HRESULT WINAPI IDirect3DPixelShaderImpl_SetConstantF(IDirect3DPixelShaderImpl* This, UINT StartRegister, CONST FLOAT* pConstantData, UINT Vector4fCount) {
1267 if (StartRegister + Vector4fCount > D3D8_VSHADER_MAX_CONSTANTS) {
1268 return D3DERR_INVALIDCALL;
1269 }
1270 if (NULL == This->data) { /* temporary while datas not supported */
1271 FIXME("(%p) : VertexShader_SetConstant not fully supported yet\n", This);
1272 return D3DERR_INVALIDCALL;
1273 }
1274 memcpy(&This->data->C[StartRegister], pConstantData, Vector4fCount * 4 * sizeof(FLOAT));
1275 return D3D_OK;
1276 }
1277
1278 HRESULT WINAPI IDirect3DPixelShaderImpl_GetConstantF(IDirect3DPixelShaderImpl* This, UINT StartRegister, FLOAT* pConstantData, UINT Vector4fCount) {
1279 if (StartRegister + Vector4fCount > D3D8_VSHADER_MAX_CONSTANTS) {
1280 return D3DERR_INVALIDCALL;
1281 }
1282 if (NULL == This->data) { /* temporary while datas not supported */
1283 return D3DERR_INVALIDCALL;
1284 }
1285 memcpy(pConstantData, &This->data->C[StartRegister], Vector4fCount * 4 * sizeof(FLOAT));
1286 return D3D_OK;
1287 }
1288
1289
1290 /**********************************************************************************************************************************************
1291 **********************************************************************************************************************************************
1292 **********************************************************************************************************************************************
1293 **********************************************************************************************************************************************
1294 **********************************************************************************************************************************************/
1295
1296 /***********************************************************************
1297 * ValidateVertexShader (D3D8.@)
1298 */
1299 BOOL WINAPI ValidateVertexShader(LPVOID what, LPVOID toto) {
1300 FIXME("(void): stub: %p %p\n", what, toto);
1301 return TRUE;
1302 }
1303
1304 /***********************************************************************
1305 * ValidatePixelShader (D3D8.@)
1306 */
1307 BOOL WINAPI ValidatePixelShader(LPVOID what, LPVOID toto) {
1308 FIXME("(void): stub: %p %p\n", what, toto);
1309 return TRUE;
1310 }
Work in progress by Kai Blin