?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
user32: Implement IDI_SHIELD.
[wine.git] / dlls / d3dcompiler_43 / compiler.c
blob36e793ed01cc794c4fadcd73d87e81666723616d
1 /*
2 * Copyright 2009 Matteo Bruni
3 * Copyright 2010 Matteo Bruni for CodeWeavers
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #define COBJMACROS
21 #include "config.h"
22 #include "wine/port.h"
23 #include "wine/debug.h"
24 #include "wine/unicode.h"
25
26 #include "d3dcompiler_private.h"
27 #include "wine/wpp.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler);
30
31 #define D3DXERR_INVALIDDATA 0x88760b59
32
33 #define BUFFER_INITIAL_CAPACITY 256
34
35 struct mem_file_desc
36 {
37 const char *buffer;
38 unsigned int size;
39 unsigned int pos;
40 };
41
42 static struct mem_file_desc current_shader;
43 static ID3DInclude *current_include;
44 static const char *initial_filename;
45
46 #define INCLUDES_INITIAL_CAPACITY 4
47
48 struct loaded_include
49 {
50 const char *name;
51 const char *data;
52 };
53
54 static struct loaded_include *includes;
55 static int includes_capacity, includes_size;
56 static const char *parent_include;
57
58 static char *wpp_output;
59 static int wpp_output_capacity, wpp_output_size;
60
61 static char *wpp_messages;
62 static int wpp_messages_capacity, wpp_messages_size;
63
64 /* Mutex used to guarantee a single invocation
65 of the D3DXAssembleShader function (or its variants) at a time.
66 This is needed as wpp isn't thread-safe */
67 static CRITICAL_SECTION wpp_mutex;
68 static CRITICAL_SECTION_DEBUG wpp_mutex_debug =
69 {
70 0, 0, &wpp_mutex,
71 { &wpp_mutex_debug.ProcessLocksList,
72 &wpp_mutex_debug.ProcessLocksList },
73 0, 0, { (DWORD_PTR)(__FILE__ ": wpp_mutex") }
74 };
75 static CRITICAL_SECTION wpp_mutex = { &wpp_mutex_debug, -1, 0, 0, 0, 0 };
76
77 /* Preprocessor error reporting functions */
78 static void wpp_write_message(const char *fmt, va_list args)
79 {
80 char* newbuffer;
81 int rc, newsize;
82
83 if(wpp_messages_capacity == 0)
84 {
85 wpp_messages = HeapAlloc(GetProcessHeap(), 0, MESSAGEBUFFER_INITIAL_SIZE);
86 if(wpp_messages == NULL)
87 return;
88
89 wpp_messages_capacity = MESSAGEBUFFER_INITIAL_SIZE;
90 }
91
92 while(1)
93 {
94 rc = vsnprintf(wpp_messages + wpp_messages_size,
95 wpp_messages_capacity - wpp_messages_size, fmt, args);
96
97 if (rc < 0 || /* C89 */
98 rc >= wpp_messages_capacity - wpp_messages_size) { /* C99 */
99 /* Resize the buffer */
100 newsize = wpp_messages_capacity * 2;
101 newbuffer = HeapReAlloc(GetProcessHeap(), 0, wpp_messages, newsize);
102 if(newbuffer == NULL)
103 {
104 ERR("Error reallocating memory for parser messages\n");
105 return;
106 }
107 wpp_messages = newbuffer;
108 wpp_messages_capacity = newsize;
109 }
110 else
111 {
112 wpp_messages_size += rc;
113 return;
114 }
115 }
116 }
117
118 static void PRINTF_ATTR(1,2) wpp_write_message_var(const char *fmt, ...)
119 {
120 va_list args;
121
122 va_start(args, fmt);
123 wpp_write_message(fmt, args);
124 va_end(args);
125 }
126
127 static void wpp_error(const char *file, int line, int col, const char *near,
128 const char *msg, va_list ap)
129 {
130 wpp_write_message_var("%s:%d:%d: %s: ", file ? file : "'main file'",
131 line, col, "Error");
132 wpp_write_message(msg, ap);
133 wpp_write_message_var("\n");
134 }
135
136 static void wpp_warning(const char *file, int line, int col, const char *near,
137 const char *msg, va_list ap)
138 {
139 wpp_write_message_var("%s:%d:%d: %s: ", file ? file : "'main file'",
140 line, col, "Warning");
141 wpp_write_message(msg, ap);
142 wpp_write_message_var("\n");
143 }
144
145 static char *wpp_lookup_mem(const char *filename, int type, const char *parent_name,
146 char **include_path, int include_path_count)
147 {
148 /* We don't check for file existence here. We will potentially fail on
149 * the following wpp_open_mem(). */
150 char *path;
151 int i;
152
153 TRACE("Looking for include %s, parent %s.\n", debugstr_a(filename), debugstr_a(parent_name));
154
155 parent_include = NULL;
156 if (strcmp(parent_name, initial_filename))
157 {
158 for(i = 0; i < includes_size; i++)
159 {
160 if(!strcmp(parent_name, includes[i].name))
161 {
162 parent_include = includes[i].data;
163 break;
164 }
165 }
166 if(parent_include == NULL)
167 {
168 ERR("Parent include %s missing.\n", debugstr_a(parent_name));
169 return NULL;
170 }
171 }
172
173 path = malloc(strlen(filename) + 1);
174 if(path)
175 memcpy(path, filename, strlen(filename) + 1);
176 return path;
177 }
178
179 static void *wpp_open_mem(const char *filename, int type)
180 {
181 struct mem_file_desc *desc;
182 HRESULT hr;
183
184 TRACE("Opening include %s.\n", debugstr_a(filename));
185
186 if(!strcmp(filename, initial_filename))
187 {
188 current_shader.pos = 0;
189 return &current_shader;
190 }
191
192 if(current_include == NULL) return NULL;
193 desc = HeapAlloc(GetProcessHeap(), 0, sizeof(*desc));
194 if(!desc)
195 return NULL;
196
197 if (FAILED(hr = ID3DInclude_Open(current_include, type ? D3D_INCLUDE_LOCAL : D3D_INCLUDE_SYSTEM,
198 filename, parent_include, (const void **)&desc->buffer, &desc->size)))
199 {
200 HeapFree(GetProcessHeap(), 0, desc);
201 return NULL;
202 }
203
204 if(includes_capacity == includes_size)
205 {
206 if(includes_capacity == 0)
207 {
208 includes = HeapAlloc(GetProcessHeap(), 0, INCLUDES_INITIAL_CAPACITY * sizeof(*includes));
209 if(includes == NULL)
210 {
211 ERR("Error allocating memory for the loaded includes structure\n");
212 goto error;
213 }
214 includes_capacity = INCLUDES_INITIAL_CAPACITY * sizeof(*includes);
215 }
216 else
217 {
218 int newcapacity = includes_capacity * 2;
219 struct loaded_include *newincludes =
220 HeapReAlloc(GetProcessHeap(), 0, includes, newcapacity);
221 if(newincludes == NULL)
222 {
223 ERR("Error reallocating memory for the loaded includes structure\n");
224 goto error;
225 }
226 includes = newincludes;
227 includes_capacity = newcapacity;
228 }
229 }
230 includes[includes_size].name = filename;
231 includes[includes_size++].data = desc->buffer;
232
233 desc->pos = 0;
234 return desc;
235
236 error:
237 ID3DInclude_Close(current_include, desc->buffer);
238 HeapFree(GetProcessHeap(), 0, desc);
239 return NULL;
240 }
241
242 static void wpp_close_mem(void *file)
243 {
244 struct mem_file_desc *desc = file;
245
246 if(desc != &current_shader)
247 {
248 if(current_include)
249 ID3DInclude_Close(current_include, desc->buffer);
250 else
251 ERR("current_include == NULL, desc == %p, buffer = %s\n",
252 desc, desc->buffer);
253
254 HeapFree(GetProcessHeap(), 0, desc);
255 }
256 }
257
258 static int wpp_read_mem(void *file, char *buffer, unsigned int len)
259 {
260 struct mem_file_desc *desc = file;
261
262 len = min(len, desc->size - desc->pos);
263 memcpy(buffer, desc->buffer + desc->pos, len);
264 desc->pos += len;
265 return len;
266 }
267
268 static void wpp_write_mem(const char *buffer, unsigned int len)
269 {
270 char *new_wpp_output;
271
272 if(wpp_output_capacity == 0)
273 {
274 wpp_output = HeapAlloc(GetProcessHeap(), 0, BUFFER_INITIAL_CAPACITY);
275 if(!wpp_output)
276 return;
277
278 wpp_output_capacity = BUFFER_INITIAL_CAPACITY;
279 }
280 if(len > wpp_output_capacity - wpp_output_size)
281 {
282 while(len > wpp_output_capacity - wpp_output_size)
283 {
284 wpp_output_capacity *= 2;
285 }
286 new_wpp_output = HeapReAlloc(GetProcessHeap(), 0, wpp_output,
287 wpp_output_capacity);
288 if(!new_wpp_output)
289 {
290 ERR("Error allocating memory\n");
291 return;
292 }
293 wpp_output = new_wpp_output;
294 }
295 memcpy(wpp_output + wpp_output_size, buffer, len);
296 wpp_output_size += len;
297 }
298
299 static int wpp_close_output(void)
300 {
301 char *new_wpp_output = HeapReAlloc(GetProcessHeap(), 0, wpp_output,
302 wpp_output_size + 1);
303 if(!new_wpp_output) return 0;
304 wpp_output = new_wpp_output;
305 wpp_output[wpp_output_size]='\0';
306 wpp_output_size++;
307 return 1;
308 }
309
310 static HRESULT preprocess_shader(const void *data, SIZE_T data_size, const char *filename,
311 const D3D_SHADER_MACRO *defines, ID3DInclude *include, ID3DBlob **error_messages)
312 {
313 int ret;
314 HRESULT hr = S_OK;
315 const D3D_SHADER_MACRO *def = defines;
316
317 static const struct wpp_callbacks wpp_callbacks =
318 {
319 wpp_lookup_mem,
320 wpp_open_mem,
321 wpp_close_mem,
322 wpp_read_mem,
323 wpp_write_mem,
324 wpp_error,
325 wpp_warning,
326 };
327
328 if (def != NULL)
329 {
330 while (def->Name != NULL)
331 {
332 wpp_add_define(def->Name, def->Definition);
333 def++;
334 }
335 }
336 current_include = include;
337 includes_size = 0;
338
339 wpp_output_size = wpp_output_capacity = 0;
340 wpp_output = NULL;
341
342 wpp_set_callbacks(&wpp_callbacks);
343 wpp_messages_size = wpp_messages_capacity = 0;
344 wpp_messages = NULL;
345 current_shader.buffer = data;
346 current_shader.size = data_size;
347 initial_filename = filename ? filename : "";
348
349 ret = wpp_parse(initial_filename, NULL);
350 if (!wpp_close_output())
351 ret = 1;
352 if (ret)
353 {
354 TRACE("Error during shader preprocessing\n");
355 if (wpp_messages)
356 {
357 int size;
358 ID3DBlob *buffer;
359
360 TRACE("Preprocessor messages:\n%s\n", debugstr_a(wpp_messages));
361
362 if (error_messages)
363 {
364 size = strlen(wpp_messages) + 1;
365 hr = D3DCreateBlob(size, &buffer);
366 if (FAILED(hr))
367 goto cleanup;
368 CopyMemory(ID3D10Blob_GetBufferPointer(buffer), wpp_messages, size);
369 *error_messages = buffer;
370 }
371 }
372 if (data)
373 TRACE("Shader source:\n%s\n", debugstr_an(data, data_size));
374 hr = E_FAIL;
375 }
376
377 cleanup:
378 /* Remove the previously added defines */
379 if (defines != NULL)
380 {
381 while (defines->Name != NULL)
382 {
383 wpp_del_define(defines->Name);
384 defines++;
385 }
386 }
387 HeapFree(GetProcessHeap(), 0, wpp_messages);
388 return hr;
389 }
390
391 static HRESULT assemble_shader(const char *preproc_shader,
392 ID3DBlob **shader_blob, ID3DBlob **error_messages)
393 {
394 struct bwriter_shader *shader;
395 char *messages = NULL;
396 HRESULT hr;
397 DWORD *res, size;
398 ID3DBlob *buffer;
399 char *pos;
400
401 shader = SlAssembleShader(preproc_shader, &messages);
402
403 if (messages)
404 {
405 TRACE("Assembler messages:\n");
406 TRACE("%s\n", debugstr_a(messages));
407
408 TRACE("Shader source:\n");
409 TRACE("%s\n", debugstr_a(preproc_shader));
410
411 if (error_messages)
412 {
413 const char *preproc_messages = *error_messages ? ID3D10Blob_GetBufferPointer(*error_messages) : NULL;
414
415 size = strlen(messages) + (preproc_messages ? strlen(preproc_messages) : 0) + 1;
416 hr = D3DCreateBlob(size, &buffer);
417 if (FAILED(hr))
418 {
419 HeapFree(GetProcessHeap(), 0, messages);
420 if (shader) SlDeleteShader(shader);
421 return hr;
422 }
423 pos = ID3D10Blob_GetBufferPointer(buffer);
424 if (preproc_messages)
425 {
426 CopyMemory(pos, preproc_messages, strlen(preproc_messages) + 1);
427 pos += strlen(preproc_messages);
428 }
429 CopyMemory(pos, messages, strlen(messages) + 1);
430
431 if (*error_messages) ID3D10Blob_Release(*error_messages);
432 *error_messages = buffer;
433 }
434 HeapFree(GetProcessHeap(), 0, messages);
435 }
436
437 if (shader == NULL)
438 {
439 ERR("Asm reading failed\n");
440 return D3DXERR_INVALIDDATA;
441 }
442
443 hr = SlWriteBytecode(shader, 9, &res, &size);
444 SlDeleteShader(shader);
445 if (FAILED(hr))
446 {
447 ERR("SlWriteBytecode failed with 0x%08x\n", hr);
448 return D3DXERR_INVALIDDATA;
449 }
450
451 if (shader_blob)
452 {
453 hr = D3DCreateBlob(size, &buffer);
454 if (FAILED(hr))
455 {
456 HeapFree(GetProcessHeap(), 0, res);
457 return hr;
458 }
459 CopyMemory(ID3D10Blob_GetBufferPointer(buffer), res, size);
460 *shader_blob = buffer;
461 }
462
463 HeapFree(GetProcessHeap(), 0, res);
464
465 return S_OK;
466 }
467
468 HRESULT WINAPI D3DAssemble(const void *data, SIZE_T datasize, const char *filename,
469 const D3D_SHADER_MACRO *defines, ID3DInclude *include, UINT flags,
470 ID3DBlob **shader, ID3DBlob **error_messages)
471 {
472 HRESULT hr;
473
474 TRACE("data %p, datasize %lu, filename %s, defines %p, include %p, sflags %#x, "
475 "shader %p, error_messages %p.\n",
476 data, datasize, debugstr_a(filename), defines, include, flags, shader, error_messages);
477
478 EnterCriticalSection(&wpp_mutex);
479
480 /* TODO: flags */
481 if (flags) FIXME("flags %x\n", flags);
482
483 if (shader) *shader = NULL;
484 if (error_messages) *error_messages = NULL;
485
486 hr = preprocess_shader(data, datasize, filename, defines, include, error_messages);
487 if (SUCCEEDED(hr))
488 hr = assemble_shader(wpp_output, shader, error_messages);
489
490 HeapFree(GetProcessHeap(), 0, wpp_output);
491 LeaveCriticalSection(&wpp_mutex);
492 return hr;
493 }
494
495 struct target_info {
496 const char *name;
497 enum shader_type type;
498 DWORD sm_major;
499 DWORD sm_minor;
500 DWORD level_major;
501 DWORD level_minor;
502 BOOL sw;
503 BOOL support;
504 };
505
506 /* Must be kept sorted for binary search */
507 static const struct target_info targets_info[] = {
508 { "cs_4_0", ST_UNKNOWN, 4, 0, 0, 0, FALSE, FALSE },
509 { "cs_4_1", ST_UNKNOWN, 4, 1, 0, 0, FALSE, FALSE },
510 { "cs_5_0", ST_UNKNOWN, 5, 0, 0, 0, FALSE, FALSE },
511 { "ds_5_0", ST_UNKNOWN, 5, 0, 0, 0, FALSE, FALSE },
512 { "fx_2_0", ST_UNKNOWN, 2, 0, 0, 0, FALSE, FALSE },
513 { "fx_4_0", ST_UNKNOWN, 4, 0, 0, 0, FALSE, FALSE },
514 { "fx_4_1", ST_UNKNOWN, 4, 1, 0, 0, FALSE, FALSE },
515 { "fx_5_0", ST_UNKNOWN, 5, 0, 0, 0, FALSE, FALSE },
516 { "gs_4_0", ST_UNKNOWN, 4, 0, 0, 0, FALSE, FALSE },
517 { "gs_4_1", ST_UNKNOWN, 4, 1, 0, 0, FALSE, FALSE },
518 { "gs_5_0", ST_UNKNOWN, 5, 0, 0, 0, FALSE, FALSE },
519 { "hs_5_0", ST_UNKNOWN, 5, 0, 0, 0, FALSE, FALSE },
520 { "ps.1.0", ST_PIXEL, 1, 0, 0, 0, FALSE, TRUE },
521 { "ps.1.1", ST_PIXEL, 1, 1, 0, 0, FALSE, FALSE },
522 { "ps.1.2", ST_PIXEL, 1, 2, 0, 0, FALSE, FALSE },
523 { "ps.1.3", ST_PIXEL, 1, 3, 0, 0, FALSE, FALSE },
524 { "ps.1.4", ST_PIXEL, 1, 4, 0, 0, FALSE, FALSE },
525 { "ps.2.0", ST_PIXEL, 2, 0, 0, 0, FALSE, TRUE },
526 { "ps.2.a", ST_PIXEL, 2, 1, 0, 0, FALSE, FALSE },
527 { "ps.2.b", ST_PIXEL, 2, 2, 0, 0, FALSE, FALSE },
528 { "ps.2.sw", ST_PIXEL, 2, 0, 0, 0, TRUE, FALSE },
529 { "ps.3.0", ST_PIXEL, 3, 0, 0, 0, FALSE, TRUE },
530 { "ps_1_0", ST_PIXEL, 1, 0, 0, 0, FALSE, TRUE },
531 { "ps_1_1", ST_PIXEL, 1, 1, 0, 0, FALSE, FALSE },
532 { "ps_1_2", ST_PIXEL, 1, 2, 0, 0, FALSE, FALSE },
533 { "ps_1_3", ST_PIXEL, 1, 3, 0, 0, FALSE, FALSE },
534 { "ps_1_4", ST_PIXEL, 1, 4, 0, 0, FALSE, FALSE },
535 { "ps_2_0", ST_PIXEL, 2, 0, 0, 0, FALSE, TRUE },
536 { "ps_2_a", ST_PIXEL, 2, 1, 0, 0, FALSE, FALSE },
537 { "ps_2_b", ST_PIXEL, 2, 2, 0, 0, FALSE, FALSE },
538 { "ps_2_sw", ST_PIXEL, 2, 0, 0, 0, TRUE, FALSE },
539 { "ps_3_0", ST_PIXEL, 3, 0, 0, 0, FALSE, TRUE },
540 { "ps_3_sw", ST_PIXEL, 3, 0, 0, 0, TRUE, FALSE },
541 { "ps_4_0", ST_PIXEL, 4, 0, 0, 0, FALSE, TRUE },
542 { "ps_4_0_level_9_0", ST_PIXEL, 4, 0, 9, 0, FALSE, FALSE },
543 { "ps_4_0_level_9_1", ST_PIXEL, 4, 0, 9, 1, FALSE, FALSE },
544 { "ps_4_0_level_9_3", ST_PIXEL, 4, 0, 9, 3, FALSE, FALSE },
545 { "ps_4_1", ST_PIXEL, 4, 1, 0, 0, FALSE, TRUE },
546 { "ps_5_0", ST_PIXEL, 5, 0, 0, 0, FALSE, TRUE },
547 { "tx_1_0", ST_UNKNOWN, 1, 0, 0, 0, FALSE, FALSE },
548 { "vs.1.0", ST_VERTEX, 1, 0, 0, 0, FALSE, TRUE },
549 { "vs.1.1", ST_VERTEX, 1, 1, 0, 0, FALSE, TRUE },
550 { "vs.2.0", ST_VERTEX, 2, 0, 0, 0, FALSE, TRUE },
551 { "vs.2.a", ST_VERTEX, 2, 1, 0, 0, FALSE, FALSE },
552 { "vs.2.sw", ST_VERTEX, 2, 0, 0, 0, TRUE, FALSE },
553 { "vs.3.0", ST_VERTEX, 3, 0, 0, 0, FALSE, TRUE },
554 { "vs.3.sw", ST_VERTEX, 3, 0, 0, 0, TRUE, FALSE },
555 { "vs_1_0", ST_VERTEX, 1, 0, 0, 0, FALSE, TRUE },
556 { "vs_1_1", ST_VERTEX, 1, 1, 0, 0, FALSE, TRUE },
557 { "vs_2_0", ST_VERTEX, 2, 0, 0, 0, FALSE, TRUE },
558 { "vs_2_a", ST_VERTEX, 2, 1, 0, 0, FALSE, FALSE },
559 { "vs_2_sw", ST_VERTEX, 2, 0, 0, 0, TRUE, FALSE },
560 { "vs_3_0", ST_VERTEX, 3, 0, 0, 0, FALSE, TRUE },
561 { "vs_3_sw", ST_VERTEX, 3, 0, 0, 0, TRUE, FALSE },
562 { "vs_4_0", ST_VERTEX, 4, 0, 0, 0, FALSE, TRUE },
563 { "vs_4_0_level_9_0", ST_VERTEX, 4, 0, 9, 0, FALSE, FALSE },
564 { "vs_4_0_level_9_1", ST_VERTEX, 4, 0, 9, 1, FALSE, FALSE },
565 { "vs_4_0_level_9_3", ST_VERTEX, 4, 0, 9, 3, FALSE, FALSE },
566 { "vs_4_1", ST_VERTEX, 4, 1, 0, 0, FALSE, TRUE },
567 { "vs_5_0", ST_VERTEX, 5, 0, 0, 0, FALSE, TRUE },
568 };
569
570 static const struct target_info * get_target_info(const char *target)
571 {
572 LONG min = 0;
573 LONG max = sizeof(targets_info) / sizeof(targets_info[0]) - 1;
574 LONG cur;
575 int res;
576
577 while (min <= max)
578 {
579 cur = (min + max) / 2;
580 res = strcmp(target, targets_info[cur].name);
581 if (res < 0)
582 max = cur - 1;
583 else if (res > 0)
584 min = cur + 1;
585 else
586 return &targets_info[cur];
587 }
588
589 return NULL;
590 }
591
592 static HRESULT compile_shader(const char *preproc_shader, const char *target, const char *entrypoint,
593 ID3DBlob **shader_blob, ID3DBlob **error_messages)
594 {
595 struct bwriter_shader *shader;
596 char *messages = NULL;
597 HRESULT hr;
598 DWORD *res, size, major, minor;
599 ID3DBlob *buffer;
600 char *pos;
601 enum shader_type shader_type;
602 const struct target_info *info;
603
604 TRACE("Preprocessed shader source: %s\n", debugstr_a(preproc_shader));
605
606 TRACE("Checking compilation target %s\n", debugstr_a(target));
607 info = get_target_info(target);
608 if (!info)
609 {
610 FIXME("Unknown compilation target %s\n", debugstr_a(target));
611 return D3DERR_INVALIDCALL;
612 }
613 else
614 {
615 if (!info->support)
616 {
617 FIXME("Compilation target %s not yet supported\n", debugstr_a(target));
618 return D3DERR_INVALIDCALL;
619 }
620 else
621 {
622 shader_type = info->type;
623 major = info->sm_major;
624 minor = info->sm_minor;
625 }
626 }
627
628 shader = parse_hlsl_shader(preproc_shader, shader_type, major, minor, entrypoint, &messages);
629
630 if (messages)
631 {
632 TRACE("Compiler messages:\n");
633 TRACE("%s\n", debugstr_a(messages));
634
635 TRACE("Shader source:\n");
636 TRACE("%s\n", debugstr_a(preproc_shader));
637
638 if (error_messages)
639 {
640 const char *preproc_messages = *error_messages ? ID3D10Blob_GetBufferPointer(*error_messages) : NULL;
641
642 size = strlen(messages) + (preproc_messages ? strlen(preproc_messages) : 0) + 1;
643 hr = D3DCreateBlob(size, &buffer);
644 if (FAILED(hr))
645 {
646 HeapFree(GetProcessHeap(), 0, messages);
647 if (shader) SlDeleteShader(shader);
648 return hr;
649 }
650 pos = ID3D10Blob_GetBufferPointer(buffer);
651 if (preproc_messages)
652 {
653 memcpy(pos, preproc_messages, strlen(preproc_messages) + 1);
654 pos += strlen(preproc_messages);
655 }
656 memcpy(pos, messages, strlen(messages) + 1);
657
658 if (*error_messages) ID3D10Blob_Release(*error_messages);
659 *error_messages = buffer;
660 }
661 HeapFree(GetProcessHeap(), 0, messages);
662 }
663
664 if (!shader)
665 {
666 ERR("HLSL shader parsing failed.\n");
667 return D3DXERR_INVALIDDATA;
668 }
669
670 hr = SlWriteBytecode(shader, 9, &res, &size);
671 SlDeleteShader(shader);
672 if (FAILED(hr))
673 {
674 ERR("SlWriteBytecode failed with error 0x%08x.\n", hr);
675 return D3DXERR_INVALIDDATA;
676 }
677
678 if (shader_blob)
679 {
680 hr = D3DCreateBlob(size, &buffer);
681 if (FAILED(hr))
682 {
683 HeapFree(GetProcessHeap(), 0, res);
684 return hr;
685 }
686 memcpy(ID3D10Blob_GetBufferPointer(buffer), res, size);
687 *shader_blob = buffer;
688 }
689
690 HeapFree(GetProcessHeap(), 0, res);
691
692 return S_OK;
693 }
694
695 HRESULT WINAPI D3DCompile2(const void *data, SIZE_T data_size, const char *filename,
696 const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint,
697 const char *target, UINT sflags, UINT eflags, UINT secondary_flags,
698 const void *secondary_data, SIZE_T secondary_data_size, ID3DBlob **shader,
699 ID3DBlob **error_messages)
700 {
701 HRESULT hr;
702
703 TRACE("data %p, data_size %lu, filename %s, defines %p, include %p, entrypoint %s, "
704 "target %s, sflags %#x, eflags %#x, secondary_flags %#x, secondary_data %p, "
705 "secondary_data_size %lu, shader %p, error_messages %p.\n",
706 data, data_size, debugstr_a(filename), defines, include, debugstr_a(entrypoint),
707 debugstr_a(target), sflags, eflags, secondary_flags, secondary_data,
708 secondary_data_size, shader, error_messages);
709
710 if (secondary_data)
711 FIXME("secondary data not implemented yet\n");
712
713 if (shader) *shader = NULL;
714 if (error_messages) *error_messages = NULL;
715
716 EnterCriticalSection(&wpp_mutex);
717
718 hr = preprocess_shader(data, data_size, filename, defines, include, error_messages);
719 if (SUCCEEDED(hr))
720 hr = compile_shader(wpp_output, target, entrypoint, shader, error_messages);
721
722 HeapFree(GetProcessHeap(), 0, wpp_output);
723 LeaveCriticalSection(&wpp_mutex);
724 return hr;
725 }
726
727 HRESULT WINAPI D3DCompile(const void *data, SIZE_T data_size, const char *filename,
728 const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint,
729 const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **error_messages)
730 {
731 TRACE("data %p, data_size %lu, filename %s, defines %p, include %p, entrypoint %s, "
732 "target %s, sflags %#x, eflags %#x, shader %p, error_messages %p.\n",
733 data, data_size, debugstr_a(filename), defines, include, debugstr_a(entrypoint),
734 debugstr_a(target), sflags, eflags, shader, error_messages);
735
736 return D3DCompile2(data, data_size, filename, defines, include, entrypoint, target, sflags,
737 eflags, 0, NULL, 0, shader, error_messages);
738 }
739
740 HRESULT WINAPI D3DPreprocess(const void *data, SIZE_T size, const char *filename,
741 const D3D_SHADER_MACRO *defines, ID3DInclude *include,
742 ID3DBlob **shader, ID3DBlob **error_messages)
743 {
744 HRESULT hr;
745 ID3DBlob *buffer;
746
747 TRACE("data %p, size %lu, filename %s, defines %p, include %p, shader %p, error_messages %p\n",
748 data, size, debugstr_a(filename), defines, include, shader, error_messages);
749
750 if (!data)
751 return E_INVALIDARG;
752
753 EnterCriticalSection(&wpp_mutex);
754
755 if (shader) *shader = NULL;
756 if (error_messages) *error_messages = NULL;
757
758 hr = preprocess_shader(data, size, filename, defines, include, error_messages);
759
760 if (SUCCEEDED(hr))
761 {
762 if (shader)
763 {
764 hr = D3DCreateBlob(wpp_output_size, &buffer);
765 if (FAILED(hr))
766 goto cleanup;
767 CopyMemory(ID3D10Blob_GetBufferPointer(buffer), wpp_output, wpp_output_size);
768 *shader = buffer;
769 }
770 else
771 hr = E_INVALIDARG;
772 }
773
774 cleanup:
775 HeapFree(GetProcessHeap(), 0, wpp_output);
776 LeaveCriticalSection(&wpp_mutex);
777 return hr;
778 }
779
780 HRESULT WINAPI D3DDisassemble(const void *data, SIZE_T size, UINT flags, const char *comments, ID3DBlob **disassembly)
781 {
782 FIXME("data %p, size %lu, flags %#x, comments %p, disassembly %p stub!\n",
783 data, size, flags, comments, disassembly);
784 return E_NOTIMPL;
785 }
786
787 HRESULT WINAPI D3DCompileFromFile(const WCHAR *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *includes,
788 const char *entrypoint, const char *target, UINT flags1, UINT flags2, ID3DBlob **code, ID3DBlob **errors)
789 {
790 FIXME("filename %s, defines %p, includes %p, entrypoint %s, target %s, flags1 %x, flags2 %x, code %p, errors %p\n",
791 debugstr_w(filename), defines, includes, debugstr_a(entrypoint), debugstr_a(target), flags1, flags2, code, errors);
792
793 return E_NOTIMPL;
794 }
795
796 HRESULT WINAPI D3DLoadModule(const void *data, SIZE_T size, ID3D11Module **module)
797 {
798 FIXME("data %p, size %lu, module %p stub!\n", data, size, module);
799 return E_NOTIMPL;
800 }
Windows API implementation