d3dx9: Partial implementation of D3DXAssembleShader function.

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 \

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 */

dlls/d3dx9_36/shader.c

 /*
  * 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 &current_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 != &current_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,