?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msvcrt: Add scheduler_resource_allocation_error class implementation.
[wine.git] / dlls / d3dx9_36 / preshader.c
blobb650f33bb1d159b3f93d0b01ffb8268074682d0d
1 /*
2 * Copyright 2016 Paul Gofman
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include "config.h"
20 #include "wine/port.h"
21
22 #include "d3dx9_private.h"
23
24 #include <float.h>
25
26 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
27
28 enum pres_ops
29 {
30 PRESHADER_OP_NOP,
31 PRESHADER_OP_MOV,
32 PRESHADER_OP_ADD,
33 PRESHADER_OP_MUL,
34 PRESHADER_OP_DOT,
35 PRESHADER_OP_NEG,
36 PRESHADER_OP_RCP,
37 PRESHADER_OP_LT,
38 PRESHADER_OP_FRC,
39 PRESHADER_OP_MIN,
40 PRESHADER_OP_MAX,
41 PRESHADER_OP_GE,
42 PRESHADER_OP_CMP,
43 PRESHADER_OP_SIN,
44 PRESHADER_OP_COS,
45 PRESHADER_OP_RSQ,
46 PRESHADER_OP_EXP,
47 PRESHADER_OP_DOTSWIZ6,
48 PRESHADER_OP_DOTSWIZ8,
49 };
50
51 typedef double (*pres_op_func)(double *args, int n);
52
53 static double pres_mov(double *args, int n) {return args[0];}
54 static double pres_add(double *args, int n) {return args[0] + args[1];}
55 static double pres_mul(double *args, int n) {return args[0] * args[1];}
56 static double pres_dot(double *args, int n)
57 {
58 int i;
59 double sum;
60
61 sum = 0.0;
62 for (i = 0; i < n; ++i)
63 sum += args[i] * args[i + n];
64 return sum;
65 }
66
67 static double pres_dotswiz6(double *args, int n)
68 {
69 return pres_dot(args, 3);
70 }
71
72 static double pres_dotswiz8(double *args, int n)
73 {
74 return pres_dot(args, 4);
75 }
76
77 static double pres_neg(double *args, int n) {return -args[0];}
78 static double pres_rcp(double *args, int n) {return 1.0 / args[0];}
79 static double pres_lt(double *args, int n) {return args[0] < args[1] ? 1.0 : 0.0;}
80 static double pres_ge(double *args, int n) {return args[0] >= args[1] ? 1.0 : 0.0;}
81 static double pres_frc(double *args, int n) {return args[0] - floor(args[0]);}
82 static double pres_min(double *args, int n) {return fmin(args[0], args[1]);}
83 static double pres_max(double *args, int n) {return fmax(args[0], args[1]);}
84 static double pres_cmp(double *args, int n) {return args[0] < 0.0 ? args[2] : args[1];}
85 static double pres_sin(double *args, int n) {return sin(args[0]);}
86 static double pres_cos(double *args, int n) {return cos(args[0]);}
87 static double pres_rsq(double *args, int n)
88 {
89 double v;
90
91 v = fabs(args[0]);
92 if (v == 0.0)
93 return INFINITY;
94 else
95 return 1.0 / sqrt(v);
96 }
97 static double pres_exp(double *args, int n) {return pow(2.0, args[0]);}
98
99 #define PRES_OPCODE_MASK 0x7ff00000
100 #define PRES_OPCODE_SHIFT 20
101 #define PRES_SCALAR_FLAG 0x80000000
102 #define PRES_NCOMP_MASK 0x0000ffff
103
104 #define FOURCC_PRES 0x53455250
105 #define FOURCC_CLIT 0x54494c43
106 #define FOURCC_FXLC 0x434c5846
107 #define FOURCC_PRSI 0x49535250
108 #define PRES_SIGN 0x46580000
109
110 struct op_info
111 {
112 unsigned int opcode;
113 char mnem[16];
114 unsigned int input_count;
115 BOOL func_all_comps;
116 pres_op_func func;
117 };
118
119 static const struct op_info pres_op_info[] =
120 {
121 {0x000, "nop", 0, 0, NULL }, /* PRESHADER_OP_NOP */
122 {0x100, "mov", 1, 0, pres_mov}, /* PRESHADER_OP_MOV */
123 {0x204, "add", 2, 0, pres_add}, /* PRESHADER_OP_ADD */
124 {0x205, "mul", 2, 0, pres_mul}, /* PRESHADER_OP_MUL */
125 {0x500, "dot", 2, 1, pres_dot}, /* PRESHADER_OP_DOT */
126 {0x101, "neg", 1, 0, pres_neg}, /* PRESHADER_OP_NEG */
127 {0x103, "rcp", 1, 0, pres_rcp}, /* PRESHADER_OP_RCP */
128 {0x202, "lt", 2, 0, pres_lt }, /* PRESHADER_OP_LT */
129 {0x104, "frc", 1, 0, pres_frc}, /* PRESHADER_OP_FRC */
130 {0x200, "min", 2, 0, pres_min}, /* PRESHADER_OP_MIN */
131 {0x201, "max", 2, 0, pres_max}, /* PRESHADER_OP_MAX */
132 {0x203, "ge", 2, 0, pres_ge }, /* PRESHADER_OP_GE */
133 {0x300, "cmp", 3, 0, pres_cmp}, /* PRESHADER_OP_CMP */
134 {0x108, "sin", 1, 0, pres_sin}, /* PRESHADER_OP_SIN */
135 {0x109, "cos", 1, 0, pres_cos}, /* PRESHADER_OP_COS */
136 {0x107, "rsq", 1, 0, pres_rsq}, /* PRESHADER_OP_RSQ */
137 {0x105, "exp", 1, 0, pres_exp}, /* PRESHADER_OP_EXP */
138 {0x70e, "d3ds_dotswiz", 6, 0, pres_dotswiz6}, /* PRESHADER_OP_DOTSWIZ6 */
139 {0x70e, "d3ds_dotswiz", 8, 0, pres_dotswiz8}, /* PRESHADER_OP_DOTSWIZ8 */
140 };
141
142 enum pres_value_type
143 {
144 PRES_VT_FLOAT,
145 PRES_VT_DOUBLE,
146 PRES_VT_INT,
147 PRES_VT_BOOL
148 };
149
150 static const struct
151 {
152 unsigned int component_size;
153 unsigned int reg_component_count;
154 enum pres_value_type type;
155 }
156 table_info[] =
157 {
158 {sizeof(double), 1, PRES_VT_DOUBLE}, /* PRES_REGTAB_IMMED */
159 {sizeof(float), 4, PRES_VT_FLOAT }, /* PRES_REGTAB_CONST */
160 {sizeof(float), 4, PRES_VT_FLOAT }, /* PRES_REGTAB_OCONST */
161 {sizeof(BOOL), 1, PRES_VT_BOOL }, /* PRES_REGTAB_OBCONST */
162 {sizeof(int), 4, PRES_VT_INT, }, /* PRES_REGTAB_OICONST */
163 /* TODO: use double precision for 64 bit */
164 {sizeof(float), 4, PRES_VT_FLOAT } /* PRES_REGTAB_TEMP */
165 };
166
167 static const char *table_symbol[] =
168 {
169 "imm", "c", "oc", "ob", "oi", "r", "(null)",
170 };
171
172 static const enum pres_reg_tables pres_regset2table[] =
173 {
174 PRES_REGTAB_OBCONST, /* D3DXRS_BOOL */
175 PRES_REGTAB_OICONST, /* D3DXRS_INT4 */
176 PRES_REGTAB_CONST, /* D3DXRS_FLOAT4 */
177 PRES_REGTAB_COUNT, /* D3DXRS_SAMPLER */
178 };
179
180 static const enum pres_reg_tables shad_regset2table[] =
181 {
182 PRES_REGTAB_OBCONST, /* D3DXRS_BOOL */
183 PRES_REGTAB_OICONST, /* D3DXRS_INT4 */
184 PRES_REGTAB_OCONST, /* D3DXRS_FLOAT4 */
185 PRES_REGTAB_COUNT, /* D3DXRS_SAMPLER */
186 };
187
188 struct d3dx_pres_operand
189 {
190 enum pres_reg_tables table;
191 /* offset is component index, not register index, e. g.
192 offset for component c3.y is 13 (3 * 4 + 1) */
193 unsigned int offset;
194 };
195
196 #define MAX_INPUTS_COUNT 8
197
198 struct d3dx_pres_ins
199 {
200 enum pres_ops op;
201 /* first input argument is scalar,
202 scalar component is propagated */
203 BOOL scalar_op;
204 unsigned int component_count;
205 struct d3dx_pres_operand inputs[MAX_INPUTS_COUNT];
206 struct d3dx_pres_operand output;
207 };
208
209 static unsigned int get_reg_offset(unsigned int table, unsigned int offset)
210 {
211 return offset / table_info[table].reg_component_count;
212 }
213
214 #define PRES_BITMASK_BLOCK_SIZE (sizeof(unsigned int) * 8)
215
216 static HRESULT init_set_constants(struct d3dx_const_tab *const_tab, ID3DXConstantTable *ctab);
217
218 static HRESULT regstore_alloc_table(struct d3dx_regstore *rs, unsigned int table)
219 {
220 unsigned int size;
221
222 size = rs->table_sizes[table] * table_info[table].reg_component_count * table_info[table].component_size;
223 if (size)
224 {
225 rs->tables[table] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
226 rs->table_value_set[table] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
227 sizeof(*rs->table_value_set[table]) *
228 ((rs->table_sizes[table] + PRES_BITMASK_BLOCK_SIZE - 1) / PRES_BITMASK_BLOCK_SIZE));
229 if (!rs->tables[table] || !rs->table_value_set[table])
230 return E_OUTOFMEMORY;
231 }
232 return D3D_OK;
233 }
234
235 static void regstore_free_tables(struct d3dx_regstore *rs)
236 {
237 unsigned int i;
238
239 for (i = 0; i < PRES_REGTAB_COUNT; ++i)
240 {
241 HeapFree(GetProcessHeap(), 0, rs->tables[i]);
242 HeapFree(GetProcessHeap(), 0, rs->table_value_set[i]);
243 }
244 }
245
246 static void regstore_set_values(struct d3dx_regstore *rs, unsigned int table, void *data,
247 unsigned int start_offset, unsigned int count)
248 {
249 unsigned int block_idx, start, end, start_block, end_block;
250
251 if (!count)
252 return;
253
254 memcpy((BYTE *)rs->tables[table] + start_offset * table_info[table].component_size,
255 data, count * table_info[table].component_size);
256
257 start = get_reg_offset(table, start_offset);
258 start_block = start / PRES_BITMASK_BLOCK_SIZE;
259 start -= start_block * PRES_BITMASK_BLOCK_SIZE;
260 end = get_reg_offset(table, start_offset + count - 1);
261 end_block = end / PRES_BITMASK_BLOCK_SIZE;
262 end = (end_block + 1) * PRES_BITMASK_BLOCK_SIZE - 1 - end;
263
264 if (start_block == end_block)
265 {
266 rs->table_value_set[table][start_block] |= (~0u << start) & (~0u >> end);
267 }
268 else
269 {
270 rs->table_value_set[table][start_block] |= ~0u << start;
271
272 for (block_idx = start_block + 1; block_idx < end_block; ++block_idx)
273 rs->table_value_set[table][block_idx] = ~0u;
274
275 rs->table_value_set[table][end_block] |= ~0u >> end;
276 }
277 }
278
279 static unsigned int regstore_is_val_set_reg(struct d3dx_regstore *rs, unsigned int table, unsigned int reg_idx)
280 {
281 return rs->table_value_set[table][reg_idx / PRES_BITMASK_BLOCK_SIZE] &
282 (1u << (reg_idx % PRES_BITMASK_BLOCK_SIZE));
283 }
284
285 static double regstore_get_double(struct d3dx_regstore *rs, unsigned int table, unsigned int offset)
286 {
287 BYTE *p;
288
289 p = (BYTE *)rs->tables[table] + table_info[table].component_size * offset;
290 switch (table_info[table].type)
291 {
292 case PRES_VT_FLOAT:
293 return *(float *)p;
294 case PRES_VT_DOUBLE:
295 return *(double *)p;
296 default:
297 FIXME("Unexpected preshader input from table %u.\n", table);
298 return NAN;
299 }
300 }
301
302 static void regstore_set_double(struct d3dx_regstore *rs, unsigned int table, unsigned int offset, double v)
303 {
304 BYTE *p;
305 unsigned int reg_idx;
306
307 p = (BYTE *)rs->tables[table] + table_info[table].component_size * offset;
308 switch (table_info[table].type)
309 {
310 case PRES_VT_FLOAT : *(float *)p = v; break;
311 case PRES_VT_DOUBLE: *(double *)p = v; break;
312 case PRES_VT_INT : *(int *)p = lrint(v); break;
313 case PRES_VT_BOOL : *(BOOL *)p = !!v; break;
314 }
315 reg_idx = get_reg_offset(table, offset);
316 rs->table_value_set[table][reg_idx / PRES_BITMASK_BLOCK_SIZE] |=
317 1u << (reg_idx % PRES_BITMASK_BLOCK_SIZE);
318 }
319
320 static void regstore_reset_table(struct d3dx_regstore *rs, unsigned int table)
321 {
322 unsigned int size;
323
324 size = rs->table_sizes[table] * table_info[table].reg_component_count * table_info[table].component_size;
325
326 memset(rs->tables[table], 0, size);
327 memset(rs->table_value_set[table], 0,
328 sizeof(*rs->table_value_set[table]) *
329 ((rs->table_sizes[table] + PRES_BITMASK_BLOCK_SIZE - 1) / PRES_BITMASK_BLOCK_SIZE));
330 }
331
332 static void dump_bytecode(void *data, unsigned int size)
333 {
334 unsigned int *bytecode = (unsigned int *)data;
335 unsigned int i, j, n;
336
337 size /= sizeof(*bytecode);
338 i = 0;
339 while (i < size)
340 {
341 n = min(size - i, 8);
342 for (j = 0; j < n; ++j)
343 TRACE("0x%08x,", bytecode[i + j]);
344 i += n;
345 TRACE("\n");
346 }
347 }
348
349 static unsigned int *find_bytecode_comment(unsigned int *ptr, unsigned int count,
350 unsigned int fourcc, unsigned int *size)
351 {
352 /* Provide at least one value in comment section on non-NULL return. */
353 while (count > 2 && (*ptr & 0xffff) == 0xfffe)
354 {
355 unsigned int section_size;
356
357 section_size = (*ptr >> 16);
358 if (!section_size || section_size + 1 > count)
359 break;
360 if (*(ptr + 1) == fourcc)
361 {
362 *size = section_size;
363 return ptr + 2;
364 }
365 count -= section_size + 1;
366 ptr += section_size + 1;
367 }
368 return NULL;
369 }
370
371 static unsigned int *parse_pres_arg(unsigned int *ptr, unsigned int count, struct d3dx_pres_operand *opr)
372 {
373 static const enum pres_reg_tables reg_table[8] =
374 {
375 PRES_REGTAB_COUNT, PRES_REGTAB_IMMED, PRES_REGTAB_CONST, PRES_REGTAB_COUNT,
376 PRES_REGTAB_OCONST, PRES_REGTAB_OBCONST, PRES_REGTAB_OICONST, PRES_REGTAB_TEMP
377 };
378
379 if (count < 3)
380 {
381 WARN("Byte code buffer ends unexpectedly.\n");
382 return NULL;
383 }
384
385 if (*ptr)
386 {
387 FIXME("Relative addressing not supported yet, word %#x.\n", *ptr);
388 return NULL;
389 }
390 ++ptr;
391
392 if (*ptr >= ARRAY_SIZE(reg_table) || reg_table[*ptr] == PRES_REGTAB_COUNT)
393 {
394 FIXME("Unsupported register table %#x.\n", *ptr);
395 return NULL;
396 }
397 opr->table = reg_table[*ptr++];
398 opr->offset = *ptr++;
399
400 if (opr->table == PRES_REGTAB_OBCONST)
401 opr->offset /= 4;
402 return ptr;
403 }
404
405 static unsigned int *parse_pres_ins(unsigned int *ptr, unsigned int count, struct d3dx_pres_ins *ins)
406 {
407 unsigned int ins_code, ins_raw;
408 unsigned int input_count;
409 unsigned int i;
410
411 if (count < 2)
412 {
413 WARN("Byte code buffer ends unexpectedly.\n");
414 return NULL;
415 }
416
417 ins_raw = *ptr++;
418 ins_code = (ins_raw & PRES_OPCODE_MASK) >> PRES_OPCODE_SHIFT;
419 ins->component_count = ins_raw & PRES_NCOMP_MASK;
420 ins->scalar_op = !!(ins_raw & PRES_SCALAR_FLAG);
421
422 if (ins->component_count < 1 || ins->component_count > 4)
423 {
424 FIXME("Unsupported number of components %u.\n", ins->component_count);
425 return NULL;
426 }
427 input_count = *ptr++;
428 count -= 2;
429 for (i = 0; i < ARRAY_SIZE(pres_op_info); ++i)
430 if (ins_code == pres_op_info[i].opcode && input_count == pres_op_info[i].input_count)
431 break;
432 if (i == ARRAY_SIZE(pres_op_info))
433 {
434 FIXME("Unknown opcode %#x, input_count %u, raw %#x.\n", ins_code, input_count, ins_raw);
435 return NULL;
436 }
437 ins->op = i;
438 if (input_count > ARRAY_SIZE(ins->inputs))
439 {
440 FIXME("Actual input args count %u exceeds inputs array size, instruction %s.\n", input_count,
441 pres_op_info[i].mnem);
442 return NULL;
443 }
444 for (i = 0; i < input_count; ++i)
445 {
446 unsigned int *p;
447
448 p = parse_pres_arg(ptr, count, &ins->inputs[i]);
449 if (!p)
450 return NULL;
451 count -= p - ptr;
452 ptr = p;
453 }
454 ptr = parse_pres_arg(ptr, count, &ins->output);
455 return ptr;
456 }
457
458 static HRESULT get_ctab_constant_desc(ID3DXConstantTable *ctab, D3DXHANDLE hc, D3DXCONSTANT_DESC *desc)
459 {
460 D3DXCONSTANT_DESC buffer[2];
461 HRESULT hr;
462 unsigned int count;
463
464 count = ARRAY_SIZE(buffer);
465 if (FAILED(hr = ID3DXConstantTable_GetConstantDesc(ctab, hc, buffer, &count)))
466 {
467 FIXME("Could not get constant desc, hr %#x.\n", hr);
468 return hr;
469 }
470 else if (count != 1)
471 {
472 FIXME("Unexpected constant descriptors count %u.\n", count);
473 return D3DERR_INVALIDCALL;
474 }
475 *desc = buffer[0];
476 return D3D_OK;
477 }
478
479 static HRESULT get_constants_desc(unsigned int *byte_code, struct d3dx_const_tab *out, struct d3dx9_base_effect *base)
480 {
481 ID3DXConstantTable *ctab;
482 D3DXCONSTANT_DESC *cdesc;
483 struct d3dx_parameter **inputs_param;
484 D3DXCONSTANTTABLE_DESC desc;
485 HRESULT hr;
486 D3DXHANDLE hc;
487 unsigned int i;
488
489 out->inputs = cdesc = NULL;
490 out->inputs_param = NULL;
491 out->input_count = 0;
492 inputs_param = NULL;
493 hr = D3DXGetShaderConstantTable(byte_code, &ctab);
494 if (FAILED(hr) || !ctab)
495 {
496 TRACE("Could not get CTAB data, hr %#x.\n", hr);
497 /* returning OK, shaders and preshaders without CTAB are valid */
498 return D3D_OK;
499 }
500 if (FAILED(hr = ID3DXConstantTable_GetDesc(ctab, &desc)))
501 {
502 FIXME("Could not get CTAB desc, hr %#x.\n", hr);
503 goto err_out;
504 }
505
506 cdesc = HeapAlloc(GetProcessHeap(), 0, sizeof(*cdesc) * desc.Constants);
507 inputs_param = HeapAlloc(GetProcessHeap(), 0, sizeof(*inputs_param) * desc.Constants);
508 if (!cdesc || !inputs_param)
509 {
510 hr = E_OUTOFMEMORY;
511 goto err_out;
512 }
513
514 for (i = 0; i < desc.Constants; ++i)
515 {
516 hc = ID3DXConstantTable_GetConstant(ctab, NULL, i);
517 if (!hc)
518 {
519 FIXME("Null constant handle.\n");
520 goto err_out;
521 }
522 if (FAILED(hr = get_ctab_constant_desc(ctab, hc, &cdesc[i])))
523 goto err_out;
524 inputs_param[i] = get_parameter_by_name(base, NULL, cdesc[i].Name);
525 if (cdesc[i].Class == D3DXPC_OBJECT)
526 TRACE("Object %s, parameter %p.\n", cdesc[i].Name, inputs_param[i]);
527 else if (!inputs_param[i])
528 WARN("Could not find parameter %s in effect.\n", cdesc[i].Name);
529 }
530 out->input_count = desc.Constants;
531 out->inputs = cdesc;
532 out->inputs_param = inputs_param;
533 hr = init_set_constants(out, ctab);
534 ID3DXConstantTable_Release(ctab);
535 return hr;
536 err_out:
537 HeapFree(GetProcessHeap(), 0, cdesc);
538 HeapFree(GetProcessHeap(), 0, inputs_param);
539 if (ctab)
540 ID3DXConstantTable_Release(ctab);
541 return hr;
542 }
543
544 static void update_table_size(unsigned int *table_sizes, unsigned int table, unsigned int max_register)
545 {
546 if (table < PRES_REGTAB_COUNT)
547 table_sizes[table] = max(table_sizes[table], max_register + 1);
548 }
549
550 static void update_table_sizes_consts(unsigned int *table_sizes, struct d3dx_const_tab *ctab)
551 {
552 unsigned int i, table, max_register;
553
554 for (i = 0; i < ctab->input_count; ++i)
555 {
556 if (!ctab->inputs[i].RegisterCount)
557 continue;
558 max_register = ctab->inputs[i].RegisterIndex + ctab->inputs[i].RegisterCount - 1;
559 table = ctab->regset2table[ctab->inputs[i].RegisterSet];
560 update_table_size(table_sizes, table, max_register);
561 }
562 }
563
564 static void dump_arg(struct d3dx_regstore *rs, const struct d3dx_pres_operand *arg, int component_count)
565 {
566 static const char *xyzw_str = "xyzw";
567 unsigned int i, table;
568
569 table = arg->table;
570 if (table == PRES_REGTAB_IMMED)
571 {
572 TRACE("(");
573 for (i = 0; i < component_count; ++i)
574 TRACE(i < component_count - 1 ? "%.16e, " : "%.16e",
575 ((double *)rs->tables[PRES_REGTAB_IMMED])[arg->offset + i]);
576 TRACE(")");
577 }
578 else
579 {
580 TRACE("%s%u.", table_symbol[table], get_reg_offset(table, arg->offset));
581 for (i = 0; i < component_count; ++i)
582 TRACE("%c", xyzw_str[(arg->offset + i) % 4]);
583 }
584 }
585
586 static void dump_registers(struct d3dx_const_tab *ctab)
587 {
588 unsigned int table, i;
589
590 for (i = 0; i < ctab->input_count; ++i)
591 {
592 table = ctab->regset2table[ctab->inputs[i].RegisterSet];
593 TRACE("// %-12s %s%-4u %u\n", ctab->inputs_param[i] ? ctab->inputs_param[i]->name : "(nil)",
594 table_symbol[table], ctab->inputs[i].RegisterIndex, ctab->inputs[i].RegisterCount);
595 }
596 }
597
598 static void dump_ins(struct d3dx_regstore *rs, const struct d3dx_pres_ins *ins)
599 {
600 unsigned int i;
601
602 TRACE(" %s ", pres_op_info[ins->op].mnem);
603 dump_arg(rs, &ins->output, pres_op_info[ins->op].func_all_comps ? 1 : ins->component_count);
604 for (i = 0; i < pres_op_info[ins->op].input_count; ++i)
605 {
606 TRACE(", ");
607 dump_arg(rs, &ins->inputs[i], ins->scalar_op && !i ? 1 : ins->component_count);
608 }
609 TRACE("\n");
610 }
611
612 static void dump_preshader(struct d3dx_preshader *pres)
613 {
614 unsigned int i;
615
616 TRACE("// Preshader registers:\n");
617 dump_registers(&pres->inputs);
618 TRACE(" preshader\n");
619 for (i = 0; i < pres->ins_count; ++i)
620 dump_ins(&pres->regs, &pres->ins[i]);
621 }
622
623 static HRESULT parse_preshader(struct d3dx_preshader *pres, unsigned int *ptr, unsigned int count, struct d3dx9_base_effect *base)
624 {
625 unsigned int *p;
626 unsigned int i, j, const_count;
627 double *dconst;
628 HRESULT hr;
629 unsigned int saved_word;
630 unsigned int section_size;
631
632 TRACE("Preshader version %#x.\n", *ptr & 0xffff);
633
634 if (!count)
635 {
636 WARN("Unexpected end of byte code buffer.\n");
637 return D3DXERR_INVALIDDATA;
638 }
639
640 p = find_bytecode_comment(ptr + 1, count - 1, FOURCC_CLIT, &section_size);
641 if (p)
642 {
643 const_count = *p++;
644 if (const_count > (section_size - 1) / (sizeof(double) / sizeof(unsigned int)))
645 {
646 WARN("Byte code buffer ends unexpectedly.\n");
647 return D3DXERR_INVALIDDATA;
648 }
649 dconst = (double *)p;
650 }
651 else
652 {
653 const_count = 0;
654 dconst = NULL;
655 }
656 TRACE("%u double constants.\n", const_count);
657
658 p = find_bytecode_comment(ptr + 1, count - 1, FOURCC_FXLC, &section_size);
659 if (!p)
660 {
661 WARN("Could not find preshader code.\n");
662 return D3D_OK;
663 }
664 pres->ins_count = *p++;
665 --section_size;
666 if (pres->ins_count > UINT_MAX / sizeof(*pres->ins))
667 {
668 WARN("Invalid instruction count %u.\n", pres->ins_count);
669 return D3DXERR_INVALIDDATA;
670 }
671 TRACE("%u instructions.\n", pres->ins_count);
672 pres->ins = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pres->ins) * pres->ins_count);
673 if (!pres->ins)
674 return E_OUTOFMEMORY;
675 for (i = 0; i < pres->ins_count; ++i)
676 {
677 unsigned int *ptr_next;
678
679 ptr_next = parse_pres_ins(p, section_size, &pres->ins[i]);
680 if (!ptr_next)
681 return D3DXERR_INVALIDDATA;
682 section_size -= ptr_next - p;
683 p = ptr_next;
684 }
685
686 pres->inputs.regset2table = pres_regset2table;
687
688 saved_word = *ptr;
689 *ptr = 0xfffe0000;
690 hr = get_constants_desc(ptr, &pres->inputs, base);
691 *ptr = saved_word;
692 if (FAILED(hr))
693 return hr;
694
695 pres->regs.table_sizes[PRES_REGTAB_IMMED] = const_count;
696
697 for (i = 0; i < pres->ins_count; ++i)
698 {
699 for (j = 0; j < pres_op_info[pres->ins[i].op].input_count; ++j)
700 update_table_size(pres->regs.table_sizes, pres->ins[i].inputs[j].table,
701 get_reg_offset(pres->ins[i].inputs[j].table,
702 pres->ins[i].inputs[j].offset + pres->ins[i].component_count - 1));
703
704 update_table_size(pres->regs.table_sizes, pres->ins[i].output.table,
705 get_reg_offset(pres->ins[i].output.table,
706 pres->ins[i].output.offset + pres->ins[i].component_count - 1));
707 }
708 update_table_sizes_consts(pres->regs.table_sizes, &pres->inputs);
709 if (FAILED(regstore_alloc_table(&pres->regs, PRES_REGTAB_IMMED)))
710 return E_OUTOFMEMORY;
711 regstore_set_values(&pres->regs, PRES_REGTAB_IMMED, dconst, 0, const_count);
712
713 return D3D_OK;
714 }
715
716 void d3dx_create_param_eval(struct d3dx9_base_effect *base_effect, void *byte_code, unsigned int byte_code_size,
717 D3DXPARAMETER_TYPE type, struct d3dx_param_eval **peval_out)
718 {
719 struct d3dx_param_eval *peval;
720 unsigned int *ptr;
721 HRESULT hr;
722 unsigned int i;
723 BOOL shader;
724 unsigned int count, pres_size;
725
726 TRACE("base_effect %p, byte_code %p, byte_code_size %u, type %u, peval_out %p.\n",
727 base_effect, byte_code, byte_code_size, type, peval_out);
728
729 count = byte_code_size / sizeof(unsigned int);
730 if (!byte_code || !count)
731 {
732 *peval_out = NULL;
733 return;
734 }
735
736 peval = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*peval));
737 if (!peval)
738 goto err_out;
739
740 peval->param_type = type;
741 switch (type)
742 {
743 case D3DXPT_VERTEXSHADER:
744 case D3DXPT_PIXELSHADER:
745 shader = TRUE;
746 break;
747 default:
748 shader = FALSE;
749 break;
750 }
751 peval->shader_inputs.regset2table = shad_regset2table;
752
753 ptr = (unsigned int *)byte_code;
754 if (shader)
755 {
756 if ((*ptr & 0xfffe0000) != 0xfffe0000)
757 {
758 FIXME("Invalid shader signature %#x.\n", *ptr);
759 goto err_out;
760 }
761 TRACE("Shader version %#x.\n", *ptr & 0xffff);
762
763 if (FAILED(hr = get_constants_desc(ptr, &peval->shader_inputs, base_effect)))
764 {
765 FIXME("Could not get shader constant table, hr %#x.\n", hr);
766 goto err_out;
767 }
768 update_table_sizes_consts(peval->pres.regs.table_sizes, &peval->shader_inputs);
769 ptr = find_bytecode_comment(ptr + 1, count - 1, FOURCC_PRES, &pres_size);
770 if (!ptr)
771 TRACE("No preshader found.\n");
772 }
773 else
774 {
775 pres_size = count;
776 }
777
778 if (ptr && FAILED(parse_preshader(&peval->pres, ptr, pres_size, base_effect)))
779 {
780 FIXME("Failed parsing preshader, byte code for analysis follows.\n");
781 dump_bytecode(byte_code, byte_code_size);
782 goto err_out;
783 }
784
785 for (i = PRES_REGTAB_FIRST_SHADER; i < PRES_REGTAB_COUNT; ++i)
786 {
787 if (FAILED(regstore_alloc_table(&peval->pres.regs, i)))
788 goto err_out;
789 }
790
791 if (TRACE_ON(d3dx))
792 {
793 dump_bytecode(byte_code, byte_code_size);
794 dump_preshader(&peval->pres);
795 if (shader)
796 {
797 TRACE("// Shader registers:\n");
798 dump_registers(&peval->shader_inputs);
799 }
800 }
801 *peval_out = peval;
802 TRACE("Created parameter evaluator %p.\n", *peval_out);
803 return;
804
805 err_out:
806 FIXME("Error creating parameter evaluator.\n");
807 d3dx_free_param_eval(peval);
808 *peval_out = NULL;
809 }
810
811 static void d3dx_free_const_tab(struct d3dx_const_tab *ctab)
812 {
813 HeapFree(GetProcessHeap(), 0, ctab->inputs);
814 HeapFree(GetProcessHeap(), 0, ctab->inputs_param);
815 HeapFree(GetProcessHeap(), 0, ctab->const_set);
816 }
817
818 static void d3dx_free_preshader(struct d3dx_preshader *pres)
819 {
820 HeapFree(GetProcessHeap(), 0, pres->ins);
821
822 regstore_free_tables(&pres->regs);
823 d3dx_free_const_tab(&pres->inputs);
824 }
825
826 void d3dx_free_param_eval(struct d3dx_param_eval *peval)
827 {
828 TRACE("peval %p.\n", peval);
829
830 if (!peval)
831 return;
832
833 d3dx_free_preshader(&peval->pres);
834 d3dx_free_const_tab(&peval->shader_inputs);
835 HeapFree(GetProcessHeap(), 0, peval);
836 }
837
838 static void set_constants(struct d3dx_regstore *rs, struct d3dx_const_tab *const_tab, BOOL update_all)
839 {
840 unsigned int const_idx;
841
842 for (const_idx = 0; const_idx < const_tab->const_set_count; ++const_idx)
843 {
844 struct d3dx_const_param_eval_output *const_set = &const_tab->const_set[const_idx];
845 unsigned int table = const_set->table;
846 struct d3dx_parameter *param = const_set->param;
847 enum pres_value_type table_type = table_info[table].type;
848 unsigned int i, j, n, start_offset;
849 unsigned int minor, major, major_stride, param_offset;
850 BOOL transpose;
851 unsigned int count;
852
853 if (!(update_all || is_param_dirty(param)))
854 continue;
855
856 transpose = (const_set->constant_class == D3DXPC_MATRIX_COLUMNS && param->class == D3DXPC_MATRIX_ROWS)
857 || (param->class == D3DXPC_MATRIX_COLUMNS && const_set->constant_class == D3DXPC_MATRIX_ROWS);
858 if (const_set->constant_class == D3DXPC_MATRIX_COLUMNS)
859 {
860 major = param->columns;
861 minor = param->rows;
862 }
863 else
864 {
865 major = param->rows;
866 minor = param->columns;
867 }
868 start_offset = const_set->register_index * table_info[table].reg_component_count;
869 major_stride = max(minor, table_info[table].reg_component_count);
870 n = min(major * major_stride,
871 const_set->register_count * table_info[table].reg_component_count + major_stride - 1) / major_stride;
872 count = n * minor;
873 if (((param->type == D3DXPT_FLOAT && table_type == PRES_VT_FLOAT)
874 || (param->type == D3DXPT_INT && table_type == PRES_VT_INT)
875 || (param->type == D3DXPT_BOOL && table_type == PRES_VT_BOOL))
876 && !transpose && minor == major_stride
877 && count == table_info[table].reg_component_count * const_set->register_count
878 && count * sizeof(unsigned int) <= param->bytes)
879 {
880 regstore_set_values(rs, table, param->data, start_offset, count);
881 continue;
882 }
883
884 for (i = 0; i < n; ++i)
885 {
886 for (j = 0; j < minor; ++j)
887 {
888 unsigned int out;
889 unsigned int *in;
890 unsigned int offset;
891
892 offset = start_offset + i * major_stride + j;
893 if (offset / table_info[table].reg_component_count >= rs->table_sizes[table])
894 {
895 if (table_info[table].reg_component_count != 1)
896 FIXME("Output offset exceeds table size, name %s, component %u.\n",
897 debugstr_a(param->name), i);
898 break;
899 }
900 if (transpose)
901 param_offset = i + j * major;
902 else
903 param_offset = i * minor + j;
904 if (param_offset * sizeof(unsigned int) >= param->bytes)
905 {
906 WARN("Parameter data is too short, name %s, component %u.\n", debugstr_a(param->name), i);
907 break;
908 }
909
910 in = (unsigned int *)param->data + param_offset;
911 switch (table_type)
912 {
913 case PRES_VT_FLOAT: set_number(&out, D3DXPT_FLOAT, in, param->type); break;
914 case PRES_VT_INT: set_number(&out, D3DXPT_INT, in, param->type); break;
915 case PRES_VT_BOOL: set_number(&out, D3DXPT_BOOL, in, param->type); break;
916 default:
917 FIXME("Unexpected type %#x.\n", table_info[table].type);
918 break;
919 }
920 regstore_set_values(rs, table, &out, offset, 1);
921 }
922 }
923 }
924 }
925
926 #define INITIAL_CONST_SET_SIZE 16
927
928 static HRESULT append_const_set(struct d3dx_const_tab *const_tab, struct d3dx_const_param_eval_output *set)
929 {
930 if (const_tab->const_set_count >= const_tab->const_set_size)
931 {
932 unsigned int new_size;
933 struct d3dx_const_param_eval_output *new_alloc;
934
935 if (!const_tab->const_set_size)
936 {
937 new_size = INITIAL_CONST_SET_SIZE;
938 new_alloc = HeapAlloc(GetProcessHeap(), 0, sizeof(*const_tab->const_set) * new_size);
939 if (!new_alloc)
940 {
941 ERR("Out of memory.\n");
942 return E_OUTOFMEMORY;
943 }
944 }
945 else
946 {
947 new_size = const_tab->const_set_size * 2;
948 new_alloc = HeapReAlloc(GetProcessHeap(), 0, const_tab->const_set,
949 sizeof(*const_tab->const_set) * new_size);
950 if (!new_alloc)
951 {
952 ERR("Out of memory.\n");
953 return E_OUTOFMEMORY;
954 }
955 }
956 const_tab->const_set = new_alloc;
957 const_tab->const_set_size = new_size;
958 }
959 const_tab->const_set[const_tab->const_set_count++] = *set;
960 return D3D_OK;
961 }
962
963 static HRESULT init_set_constants_param(struct d3dx_const_tab *const_tab, ID3DXConstantTable *ctab,
964 D3DXHANDLE hc, struct d3dx_parameter *param)
965 {
966 D3DXCONSTANT_DESC desc;
967 unsigned int const_count, param_count, i;
968 BOOL get_element;
969 struct d3dx_const_param_eval_output const_set;
970 HRESULT hr;
971
972 if (FAILED(get_ctab_constant_desc(ctab, hc, &desc)))
973 return D3DERR_INVALIDCALL;
974
975 if (param->element_count)
976 {
977 param_count = param->element_count;
978 const_count = desc.Elements;
979 get_element = TRUE;
980 }
981 else
982 {
983 if (desc.Elements > 1)
984 {
985 FIXME("Unexpected number of constant elements %u.\n", desc.Elements);
986 return D3DERR_INVALIDCALL;
987 }
988 param_count = param->member_count;
989 const_count = desc.StructMembers;
990 get_element = FALSE;
991 }
992 if (const_count != param_count)
993 {
994 FIXME("Number of elements or struct members differs between parameter (%u) and constant (%u).\n",
995 param_count, const_count);
996 return D3DERR_INVALIDCALL;
997 }
998 if (const_count)
999 {
1000 HRESULT ret;
1001 D3DXHANDLE hc_element;
1002
1003 ret = D3D_OK;
1004 for (i = 0; i < const_count; ++i)
1005 {
1006 if (get_element)
1007 hc_element = ID3DXConstantTable_GetConstantElement(ctab, hc, i);
1008 else
1009 hc_element = ID3DXConstantTable_GetConstant(ctab, hc, i);
1010 if (!hc_element)
1011 {
1012 FIXME("Could not get constant.\n");
1013 hr = D3DERR_INVALIDCALL;
1014 }
1015 else
1016 {
1017 hr = init_set_constants_param(const_tab, ctab, hc_element, &param->members[i]);
1018 }
1019 if (FAILED(hr))
1020 ret = hr;
1021 }
1022 return ret;
1023 }
1024
1025 TRACE("Constant %s, rows %u, columns %u, class %u, bytes %u.\n",
1026 debugstr_a(desc.Name), desc.Rows, desc.Columns, desc.Class, desc.Bytes);
1027 TRACE("Parameter %s, rows %u, columns %u, class %u, flags %#x, bytes %u.\n",
1028 debugstr_a(param->name), param->rows, param->columns, param->class,
1029 param->flags, param->bytes);
1030
1031 const_set.param = param;
1032 const_set.constant_class = desc.Class;
1033 if (desc.RegisterSet >= ARRAY_SIZE(shad_regset2table))
1034 {
1035 FIXME("Unknown register set %u.\n", desc.RegisterSet);
1036 return D3DERR_INVALIDCALL;
1037 }
1038 const_set.register_index = desc.RegisterIndex;
1039 const_set.table = const_tab->regset2table[desc.RegisterSet];
1040 if (const_set.table >= PRES_REGTAB_COUNT)
1041 {
1042 ERR("Unexpected register set %u.\n", desc.RegisterSet);
1043 return D3DERR_INVALIDCALL;
1044 }
1045 const_set.register_count = desc.RegisterCount;
1046 if (FAILED(hr = append_const_set(const_tab, &const_set)))
1047 return hr;
1048
1049 return D3D_OK;
1050 }
1051
1052 static HRESULT init_set_constants(struct d3dx_const_tab *const_tab, ID3DXConstantTable *ctab)
1053 {
1054 unsigned int i;
1055 HRESULT hr, ret;
1056 D3DXHANDLE hc;
1057
1058 ret = D3D_OK;
1059 for (i = 0; i < const_tab->input_count; ++i)
1060 {
1061 if (!const_tab->inputs_param[i] || const_tab->inputs_param[i]->class == D3DXPC_OBJECT)
1062 continue;
1063 hc = ID3DXConstantTable_GetConstant(ctab, NULL, i);
1064 if (hc)
1065 {
1066 hr = init_set_constants_param(const_tab, ctab, hc, const_tab->inputs_param[i]);
1067 }
1068 else
1069 {
1070 FIXME("Could not get constant, index %u.\n", i);
1071 hr = D3DERR_INVALIDCALL;
1072 }
1073 if (FAILED(hr))
1074 ret = hr;
1075 }
1076
1077 if (const_tab->const_set_count)
1078 {
1079 const_tab->const_set = HeapReAlloc(GetProcessHeap(), 0, const_tab->const_set,
1080 sizeof(*const_tab->const_set) * const_tab->const_set_count);
1081 if (!const_tab->const_set)
1082 {
1083 ERR("Out of memory.\n");
1084 return E_OUTOFMEMORY;
1085 }
1086 const_tab->const_set_size = const_tab->const_set_count;
1087 }
1088 return ret;
1089 }
1090
1091 static double exec_get_arg(struct d3dx_regstore *rs, const struct d3dx_pres_ins *ins,
1092 const struct d3dx_pres_operand *opr, unsigned int comp)
1093 {
1094 if (!regstore_is_val_set_reg(rs, opr->table, (opr->offset + comp) / table_info[opr->table].reg_component_count))
1095 {
1096 WARN("Using uninitialized input ");
1097 dump_arg(rs, opr, comp);
1098 TRACE(".\n");
1099 dump_ins(rs, ins);
1100 }
1101 return regstore_get_double(rs, opr->table, opr->offset + comp);
1102 }
1103
1104 static void exec_set_arg(struct d3dx_regstore *rs, const struct d3dx_pres_operand *opr,
1105 unsigned int comp, double res)
1106 {
1107 regstore_set_double(rs, opr->table, opr->offset + comp, res);
1108 }
1109
1110 #define ARGS_ARRAY_SIZE 8
1111 static HRESULT execute_preshader(struct d3dx_preshader *pres)
1112 {
1113 unsigned int i, j, k;
1114 double args[ARGS_ARRAY_SIZE];
1115 double res;
1116
1117 for (i = 0; i < pres->ins_count; ++i)
1118 {
1119 const struct d3dx_pres_ins *ins;
1120 const struct op_info *oi;
1121
1122 ins = &pres->ins[i];
1123 oi = &pres_op_info[ins->op];
1124 if (oi->func_all_comps)
1125 {
1126 if (oi->input_count * ins->component_count > ARGS_ARRAY_SIZE)
1127 {
1128 FIXME("Too many arguments (%u) for one instruction.\n", oi->input_count * ins->component_count);
1129 return E_FAIL;
1130 }
1131 for (k = 0; k < oi->input_count; ++k)
1132 for (j = 0; j < ins->component_count; ++j)
1133 args[k * ins->component_count + j] = exec_get_arg(&pres->regs, ins, &ins->inputs[k],
1134 ins->scalar_op && !k ? 0 : j);
1135 res = oi->func(args, ins->component_count);
1136
1137 /* only 'dot' instruction currently falls here */
1138 exec_set_arg(&pres->regs, &ins->output, 0, res);
1139 }
1140 else
1141 {
1142 for (j = 0; j < ins->component_count; ++j)
1143 {
1144 for (k = 0; k < oi->input_count; ++k)
1145 args[k] = exec_get_arg(&pres->regs, ins, &ins->inputs[k], ins->scalar_op && !k ? 0 : j);
1146 res = oi->func(args, ins->component_count);
1147 exec_set_arg(&pres->regs, &ins->output, j, res);
1148 }
1149 }
1150 }
1151 return D3D_OK;
1152 }
1153
1154 static BOOL is_const_tab_input_dirty(struct d3dx_const_tab *ctab)
1155 {
1156 unsigned int i;
1157
1158 for (i = 0; i < ctab->const_set_count; ++i)
1159 {
1160 if (is_param_dirty(ctab->const_set[i].param))
1161 return TRUE;
1162 }
1163 return FALSE;
1164 }
1165
1166 BOOL is_param_eval_input_dirty(struct d3dx_param_eval *peval)
1167 {
1168 return is_const_tab_input_dirty(&peval->pres.inputs)
1169 || is_const_tab_input_dirty(&peval->shader_inputs);
1170 }
1171
1172 HRESULT d3dx_evaluate_parameter(struct d3dx_param_eval *peval, const struct d3dx_parameter *param,
1173 void *param_value, BOOL update_all)
1174 {
1175 HRESULT hr;
1176 unsigned int i;
1177 unsigned int elements, elements_param, elements_table;
1178 float *oc;
1179
1180 TRACE("peval %p, param %p, param_value %p.\n", peval, param, param_value);
1181
1182 set_constants(&peval->pres.regs, &peval->pres.inputs, update_all);
1183
1184 if (FAILED(hr = execute_preshader(&peval->pres)))
1185 return hr;
1186
1187 elements_table = table_info[PRES_REGTAB_OCONST].reg_component_count
1188 * peval->pres.regs.table_sizes[PRES_REGTAB_OCONST];
1189 elements_param = param->bytes / sizeof(unsigned int);
1190 elements = min(elements_table, elements_param);
1191 oc = (float *)peval->pres.regs.tables[PRES_REGTAB_OCONST];
1192 for (i = 0; i < elements; ++i)
1193 set_number((unsigned int *)param_value + i, param->type, oc + i, D3DXPT_FLOAT);
1194 return D3D_OK;
1195 }
1196
1197 static HRESULT set_shader_constants_device(struct IDirect3DDevice9 *device, struct d3dx_regstore *rs,
1198 D3DXPARAMETER_TYPE type, enum pres_reg_tables table)
1199 {
1200 unsigned int start, count;
1201 void *ptr;
1202 HRESULT hr, result;
1203
1204 result = D3D_OK;
1205 start = 0;
1206 while (start < rs->table_sizes[table])
1207 {
1208 count = 0;
1209 while (start < rs->table_sizes[table] && !regstore_is_val_set_reg(rs, table, start))
1210 ++start;
1211 while (start + count < rs->table_sizes[table] && regstore_is_val_set_reg(rs, table, start + count))
1212 ++count;
1213 if (!count)
1214 break;
1215 TRACE("Setting %u constants at %u.\n", count, start);
1216 ptr = (BYTE *)rs->tables[table] + start * table_info[table].reg_component_count
1217 * table_info[table].component_size;
1218 if (type == D3DXPT_VERTEXSHADER)
1219 {
1220 switch(table)
1221 {
1222 case PRES_REGTAB_OCONST:
1223 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, start, (const float *)ptr, count);
1224 break;
1225 case PRES_REGTAB_OICONST:
1226 hr = IDirect3DDevice9_SetVertexShaderConstantI(device, start, (const int *)ptr, count);
1227 break;
1228 case PRES_REGTAB_OBCONST:
1229 hr = IDirect3DDevice9_SetVertexShaderConstantB(device, start, (const BOOL *)ptr, count);
1230 break;
1231 default:
1232 FIXME("Unexpected register table %u.\n", table);
1233 return D3DERR_INVALIDCALL;
1234 }
1235 }
1236 else if (type == D3DXPT_PIXELSHADER)
1237 {
1238 switch(table)
1239 {
1240 case PRES_REGTAB_OCONST:
1241 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, start, (const float *)ptr, count);
1242 break;
1243 case PRES_REGTAB_OICONST:
1244 hr = IDirect3DDevice9_SetPixelShaderConstantI(device, start, (const int *)ptr, count);
1245 break;
1246 case PRES_REGTAB_OBCONST:
1247 hr = IDirect3DDevice9_SetPixelShaderConstantB(device, start, (const BOOL *)ptr, count);
1248 break;
1249 default:
1250 FIXME("Unexpected register table %u.\n", table);
1251 return D3DERR_INVALIDCALL;
1252 }
1253 }
1254 else
1255 {
1256 FIXME("Unexpected parameter type %u.\n", type);
1257 return D3DERR_INVALIDCALL;
1258 }
1259
1260 if (FAILED(hr))
1261 {
1262 ERR("Setting constants failed, type %u, table %u, hr %#x.\n", type, table, hr);
1263 result = hr;
1264 }
1265 start += count;
1266 }
1267 regstore_reset_table(rs, table);
1268 return result;
1269 }
1270
1271 HRESULT d3dx_param_eval_set_shader_constants(struct IDirect3DDevice9 *device, struct d3dx_param_eval *peval,
1272 BOOL update_all)
1273 {
1274 static const enum pres_reg_tables set_tables[] =
1275 {PRES_REGTAB_OCONST, PRES_REGTAB_OICONST, PRES_REGTAB_OBCONST};
1276 HRESULT hr, result;
1277 struct d3dx_preshader *pres = &peval->pres;
1278 struct d3dx_regstore *rs = &pres->regs;
1279 unsigned int i;
1280
1281 TRACE("device %p, peval %p, param_type %u.\n", device, peval, peval->param_type);
1282
1283 if (update_all || is_const_tab_input_dirty(&pres->inputs))
1284 {
1285 set_constants(rs, &pres->inputs, update_all);
1286 if (FAILED(hr = execute_preshader(pres)))
1287 return hr;
1288 }
1289
1290 set_constants(rs, &peval->shader_inputs, update_all);
1291 result = D3D_OK;
1292 for (i = 0; i < ARRAY_SIZE(set_tables); ++i)
1293 {
1294 if (FAILED(hr = set_shader_constants_device(device, rs, peval->param_type, set_tables[i])))
1295 result = hr;
1296 }
1297 return result;
1298 }
Windows API implementation