diff --git a/dlls/d3dx9_36/Makefile.in b/dlls/d3dx9_36/Makefile.in index 8bbd78df4f3..3d6ef4ec629 100644 --- a/dlls/d3dx9_36/Makefile.in +++ b/dlls/d3dx9_36/Makefile.in @@ -5,6 +5,7 @@ VPATH = @srcdir@ MODULE = d3dx9_36.dll IMPORTLIB = d3dx9 IMPORTS = d3d9 gdi32 user32 kernel32 +EXTRALIBS = $(LIBWPP) C_SRCS = \ core.c \ diff --git a/dlls/d3dx9_36/d3dx9_36_private.h b/dlls/d3dx9_36/d3dx9_36_private.h index cca440384c0..13b84df22d3 100644 --- a/dlls/d3dx9_36/d3dx9_36_private.h +++ b/dlls/d3dx9_36/d3dx9_36_private.h @@ -128,5 +128,12 @@ typedef struct ID3DXSpriteImpl int allocated_sprites; /* number of (pre-)allocated sprites */ } ID3DXSpriteImpl; +#define MESSAGEBUFFER_INITIAL_SIZE 256 + +#ifdef __GNUC__ +#define PRINTF_ATTR(fmt,args) __attribute__((format (printf,fmt,args))) +#else +#define PRINTF_ATTR(fmt,args) +#endif #endif /* __WINE_D3DX9_36_PRIVATE_H */ diff --git a/dlls/d3dx9_36/shader.c b/dlls/d3dx9_36/shader.c index ab570291c5c..b41fee98d57 100644 --- a/dlls/d3dx9_36/shader.c +++ b/dlls/d3dx9_36/shader.c @@ -1,5 +1,6 @@ /* * Copyright 2008 Luis Busquets + * Copyright 2009 Matteo Bruni * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -22,6 +23,7 @@ #include "wine/unicode.h" #include "windef.h" #include "wingdi.h" +#include "wine/wpp.h" #include "d3dx9_36_private.h" WINE_DEFAULT_DEBUG_CHANNEL(d3dx); @@ -168,6 +170,218 @@ HRESULT WINAPI D3DXFindShaderComment(CONST DWORD* byte_code, DWORD fourcc, LPCVO return S_FALSE; } +#define BUFFER_INITIAL_CAPACITY 256 + +struct mem_file_desc +{ + const char *buffer; + unsigned int size; + unsigned int pos; +}; + +struct mem_file_desc current_shader; +LPD3DXINCLUDE current_include; +char *wpp_output; +int wpp_output_capacity, wpp_output_size; + +char *wpp_messages; +int wpp_messages_capacity, wpp_messages_size; + +/* Mutex used to guarantee a single invocation + of the D3DXAssembleShader function (or its variants) at a time. + This is needed as wpp isn't thread-safe */ +static CRITICAL_SECTION wpp_mutex; +static CRITICAL_SECTION_DEBUG wpp_mutex_debug = +{ + 0, 0, &wpp_mutex, + { &wpp_mutex_debug.ProcessLocksList, + &wpp_mutex_debug.ProcessLocksList }, + 0, 0, { (DWORD_PTR)(__FILE__ ": wpp_mutex") } +}; +static CRITICAL_SECTION wpp_mutex = { &wpp_mutex_debug, -1, 0, 0, 0, 0 }; + +/* Preprocessor error reporting functions */ +static void wpp_write_message(const char *fmt, va_list args) +{ + char* newbuffer; + int rc, newsize; + + if(wpp_messages_capacity == 0) + { + wpp_messages = HeapAlloc(GetProcessHeap(), 0, MESSAGEBUFFER_INITIAL_SIZE); + if(wpp_messages == NULL) + { + ERR("Error allocating memory for parser messages\n"); + return; + } + wpp_messages_capacity = MESSAGEBUFFER_INITIAL_SIZE; + } + + while(1) + { + rc = vsnprintf(wpp_messages + wpp_messages_size, + wpp_messages_capacity - wpp_messages_size, fmt, args); + + if (rc < 0 || /* C89 */ + rc >= wpp_messages_capacity - wpp_messages_size) { /* C99 */ + /* Resize the buffer */ + newsize = wpp_messages_capacity * 2; + newbuffer = HeapReAlloc(GetProcessHeap(), 0, wpp_messages, newsize); + if(newbuffer == NULL) + { + ERR("Error reallocating memory for parser messages\n"); + return; + } + wpp_messages = newbuffer; + wpp_messages_capacity = newsize; + } + else + { + wpp_messages_size += rc; + return; + } + } +} + +static void PRINTF_ATTR(1,2) wpp_write_message_var(const char *fmt, ...) +{ + va_list args; + + va_start(args, fmt); + wpp_write_message(fmt, args); + va_end(args); +} + +static void wpp_error(const char *file, int line, int col, const char *near, + const char *msg, va_list ap) +{ + wpp_write_message_var("%s:%d:%d: %s: ", file ? file : "'main file'", + line, col, "Error"); + wpp_write_message(msg, ap); + wpp_write_message_var("\n"); +} + +static void wpp_warning(const char *file, int line, int col, const char *near, + const char *msg, va_list ap) +{ + wpp_write_message_var("%s:%d:%d: %s: ", file ? file : "'main file'", + line, col, "Warning"); + wpp_write_message(msg, ap); + wpp_write_message_var("\n"); +} + +static char *wpp_lookup_mem(const char *filename, const char *parent_name, + char **include_path, int include_path_count) +{ + /* Here we return always ok. We will maybe fail on the next wpp_open_mem */ + char *path; + + path = malloc(strlen(filename) + 1); + if(!path) return NULL; + memcpy(path, filename, strlen(filename) + 1); + return path; +} + +static void *wpp_open_mem(const char *filename, int type) +{ + struct mem_file_desc *desc; + HRESULT hr; + + if(filename[0] == '\0') /* "" means to load the initial shader */ + { + current_shader.pos = 0; + return ¤t_shader; + } + + if(current_include == NULL) return NULL; + desc = HeapAlloc(GetProcessHeap(), 0, sizeof(*desc)); + if(!desc) + { + ERR("Error allocating memory\n"); + return NULL; + } + hr = ID3DXInclude_Open(current_include, + type ? D3DXINC_SYSTEM : D3DXINC_LOCAL, + filename, NULL, (LPCVOID *)&desc->buffer, + &desc->size); + if(FAILED(hr)) + { + HeapFree(GetProcessHeap(), 0, desc); + return NULL; + } + desc->pos = 0; + return desc; +} + +static void wpp_close_mem(void *file) +{ + struct mem_file_desc *desc = file; + + if(desc != ¤t_shader) + { + if(current_include) + ID3DXInclude_Close(current_include, desc->buffer); + else + ERR("current_include == NULL, desc == %p, buffer = %s\n", + desc, desc->buffer); + + HeapFree(GetProcessHeap(), 0, desc); + } +} + +static int wpp_read_mem(void *file, char *buffer, unsigned int len) +{ + struct mem_file_desc *desc = file; + + len = min(len, desc->size - desc->pos); + memcpy(buffer, desc->buffer + desc->pos, len); + desc->pos += len; + return len; +} + +static void wpp_write_mem(const char *buffer, unsigned int len) +{ + char *new_wpp_output; + + if(wpp_output_capacity == 0) + { + wpp_output = HeapAlloc(GetProcessHeap(), 0, BUFFER_INITIAL_CAPACITY); + if(!wpp_output) + { + ERR("Error allocating memory\n"); + return; + } + wpp_output_capacity = BUFFER_INITIAL_CAPACITY; + } + if(len > wpp_output_capacity - wpp_output_size) + { + while(len > wpp_output_capacity - wpp_output_size) + { + wpp_output_capacity *= 2; + } + new_wpp_output = HeapReAlloc(GetProcessHeap(), 0, wpp_output, + wpp_output_capacity); + if(!new_wpp_output) + { + ERR("Error allocating memory\n"); + return; + } + wpp_output = new_wpp_output; + } + memcpy(wpp_output + wpp_output_size, buffer, len); + wpp_output_size += len; +} + +static int wpp_close_output(void) +{ + char *new_wpp_output = HeapReAlloc(GetProcessHeap(), 0, wpp_output, + wpp_output_size + 1); + if(!new_wpp_output) return 0; + wpp_output = new_wpp_output; + wpp_output[wpp_output_size]='\0'; + return 1; +} + HRESULT WINAPI D3DXAssembleShader(LPCSTR data, UINT data_len, CONST D3DXMACRO* defines, @@ -176,8 +390,92 @@ HRESULT WINAPI D3DXAssembleShader(LPCSTR data, LPD3DXBUFFER* shader, LPD3DXBUFFER* error_messages) { + int ret; + HRESULT hr; + CONST D3DXMACRO* def = defines; + + static const struct wpp_callbacks wpp_callbacks = { + wpp_lookup_mem, + wpp_open_mem, + wpp_close_mem, + wpp_read_mem, + wpp_write_mem, + wpp_error, + wpp_warning, + }; + + EnterCriticalSection(&wpp_mutex); + + /* TODO: flags */ + if(flags) FIXME("flags: %x\n", flags); + + if(def != NULL) + { + while(def->Name != NULL) + { + wpp_add_define(def->Name, def->Definition); + def++; + } + } + current_include = include; + + *shader = *error_messages = NULL; + wpp_output_size = wpp_output_capacity = 0; + wpp_output = NULL; + + /* Preprocess shader */ + wpp_set_callbacks(&wpp_callbacks); + wpp_messages_size = wpp_messages_capacity = 0; + wpp_messages = NULL; + current_shader.buffer = data; + current_shader.size = data_len; + + ret = wpp_parse("", NULL); + if(!wpp_close_output()) + ret = 1; + if(ret) + { + TRACE("Error during shader preprocessing\n"); + if(wpp_messages) + { + int size; + LPD3DXBUFFER buffer; + + TRACE("Preprocessor messages:\n"); + TRACE("%s", wpp_messages); + + size = strlen(wpp_messages) + 1; + hr = D3DXCreateBuffer(size, &buffer); + if(FAILED(hr)) goto cleanup; + CopyMemory(ID3DXBuffer_GetBufferPointer(buffer), wpp_messages, size); + *error_messages = buffer; + } + if(data) + { + TRACE("Shader source:\n"); + TRACE("%s\n", debugstr_an(data, data_len)); + } + hr = D3DXERR_INVALIDDATA; + goto cleanup; + } + FIXME("(%p, %d, %p, %p, %x, %p, %p): stub\n", data, data_len, defines, include, flags, shader, error_messages); - return D3DERR_INVALIDCALL; + hr = D3DERR_INVALIDCALL; + +cleanup: + /* Remove the previously added defines */ + if(defines != NULL) + { + while(defines->Name != NULL) + { + wpp_del_define(defines->Name); + defines++; + } + } + HeapFree(GetProcessHeap(), 0, wpp_messages); + HeapFree(GetProcessHeap(), 0, wpp_output); + LeaveCriticalSection(&wpp_mutex); + return hr; } HRESULT WINAPI D3DXAssembleShaderFromFileA(LPCSTR filename,