libs: Import upstream code from vkd3d release 1.3.

configure

@@ -718,6 +718,8 @@ XSLT_PE_LIBS
 XSLT_PE_CFLAGS
 XML2_PE_LIBS
 XML2_PE_CFLAGS
+VKD3D_PE_LIBS
+VKD3D_PE_CFLAGS
 TIFF_PE_LIBS
 TIFF_PE_CFLAGS
 PNG_PE_LIBS
@@ -1537,6 +1539,7 @@ enable_strmbase
 enable_strmiids
 enable_tiff
 enable_uuid
+enable_vkd3d
 enable_wbemuuid
 enable_wine
 enable_wmcodecdspuuid
@@ -1687,6 +1690,8 @@ PNG_PE_CFLAGS
 PNG_PE_LIBS
 TIFF_PE_CFLAGS
 TIFF_PE_LIBS
+VKD3D_PE_CFLAGS
+VKD3D_PE_LIBS
 XML2_PE_CFLAGS
 XML2_PE_LIBS
 XSLT_PE_CFLAGS
@@ -2477,6 +2482,11 @@ Some influential environment variables:
               C compiler flags for the PE tiff, overriding the bundled version
   TIFF_PE_LIBS
               Linker flags for the PE tiff, overriding the bundled version
+  VKD3D_PE_CFLAGS
+              C compiler flags for the PE vkd3d, overriding the bundled
+              version
+  VKD3D_PE_LIBS
+              Linker flags for the PE vkd3d, overriding the bundled version
   XML2_PE_CFLAGS
               C compiler flags for the PE xml2, overriding the bundled version
   XML2_PE_LIBS
@@ -13063,6 +13073,21 @@ fi
 printf "%s\n" "$as_me:${as_lineno-$LINENO}: tiff cflags: $TIFF_PE_CFLAGS" >&5
 printf "%s\n" "$as_me:${as_lineno-$LINENO}: tiff libs: $TIFF_PE_LIBS" >&5
 
+if ${VKD3D_PE_LIBS:+false} :
+then :
+  VKD3D_PE_LIBS=vkd3d
+   if ${VKD3D_PE_CFLAGS:+false} :
+then :
+  VKD3D_PE_CFLAGS="-I\$(top_srcdir)/libs/vkd3d/include"
+else $as_nop
+  enable_vkd3d=no
+fi
+else $as_nop
+  enable_vkd3d=no
+fi
+printf "%s\n" "$as_me:${as_lineno-$LINENO}: vkd3d cflags: $VKD3D_PE_CFLAGS" >&5
+printf "%s\n" "$as_me:${as_lineno-$LINENO}: vkd3d libs: $VKD3D_PE_LIBS" >&5
+
 if ${XML2_PE_LIBS:+false} :
 then :
   XML2_PE_LIBS=xml2
@@ -22036,6 +22061,7 @@ wine_fn_config_makefile libs/strmbase enable_strmbase
 wine_fn_config_makefile libs/strmiids enable_strmiids
 wine_fn_config_makefile libs/tiff enable_tiff
 wine_fn_config_makefile libs/uuid enable_uuid
+wine_fn_config_makefile libs/vkd3d enable_vkd3d
 wine_fn_config_makefile libs/wbemuuid enable_wbemuuid
 wine_fn_config_makefile libs/wine enable_wine
 wine_fn_config_makefile libs/wmcodecdspuuid enable_wmcodecdspuuid
@@ -23151,6 +23177,8 @@ PNG_PE_CFLAGS = $PNG_PE_CFLAGS
 PNG_PE_LIBS = $PNG_PE_LIBS
 TIFF_PE_CFLAGS = $TIFF_PE_CFLAGS
 TIFF_PE_LIBS = $TIFF_PE_LIBS
+VKD3D_PE_CFLAGS = $VKD3D_PE_CFLAGS
+VKD3D_PE_LIBS = $VKD3D_PE_LIBS
 XML2_PE_CFLAGS = $XML2_PE_CFLAGS
 XML2_PE_LIBS = $XML2_PE_LIBS
 XSLT_PE_CFLAGS = $XSLT_PE_CFLAGS

configure.ac

@@ -1104,6 +1104,7 @@ WINE_EXTLIB_FLAGS(LCMS2, lcms2, lcms2, "-I\$(top_srcdir)/libs/lcms2/include")
 WINE_EXTLIB_FLAGS(MPG123, mpg123, mpg123, "-I\$(top_srcdir)/libs/mpg123/src/libmpg123")
 WINE_EXTLIB_FLAGS(PNG, png, "png \$(ZLIB_PE_LIBS)", "-I\$(top_srcdir)/libs/png")
 WINE_EXTLIB_FLAGS(TIFF, tiff, "tiff \$(ZLIB_PE_LIBS)", "-I\$(top_srcdir)/libs/tiff/libtiff")
+WINE_EXTLIB_FLAGS(VKD3D, vkd3d, vkd3d, "-I\$(top_srcdir)/libs/vkd3d/include")
 WINE_EXTLIB_FLAGS(XML2, xml2, xml2, "-I\$(top_srcdir)/libs/xml2/include -DLIBXML_STATIC")
 WINE_EXTLIB_FLAGS(XSLT, xslt, xslt, "-I\$(top_srcdir)/libs/xslt -DLIBXSLT_STATIC")
 WINE_EXTLIB_FLAGS(ZLIB, zlib, z, "-I\$(top_srcdir)/libs/zlib -DFAR= -DZ_SOLO")
@@ -3245,6 +3246,7 @@ WINE_CONFIG_MAKEFILE(libs/strmbase)
 WINE_CONFIG_MAKEFILE(libs/strmiids)
 WINE_CONFIG_MAKEFILE(libs/tiff)
 WINE_CONFIG_MAKEFILE(libs/uuid)
+WINE_CONFIG_MAKEFILE(libs/vkd3d)
 WINE_CONFIG_MAKEFILE(libs/wbemuuid)
 WINE_CONFIG_MAKEFILE(libs/wine)
 WINE_CONFIG_MAKEFILE(libs/wmcodecdspuuid)

libs/vkd3d/AUTHORS

+Alexandre Julliard
+Andrew Eikum
+Andrey Gusev
+Atharva Nimbalkar
+Biswapriyo Nath
+Chip Davis
+Conor McCarthy
+Derek Lesho
+Francisco Casas
+Giovanni Mascellani
+Hans-Kristian Arntzen
+Henri Verbeet
+Isabella Bosia
+Jactry Zeng
+Joshua Ashton
+Józef Kucia
+Matteo Bruni
+Nikolay Sivov
+Philip Rebohle
+Rémi Bernon
+Robin Kertels
+Stefan Dösinger
+Sven Hesse
+Vinson Lee
+Zebediah Figura
+Zhiyi Zhang

libs/vkd3d/COPYING

+Copyright 2016-2022 the Vkd3d project authors (see the file AUTHORS for a
+complete list)
+
+Vkd3d is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 2.1 of the License, or (at
+your option) any later version.
+
+This library is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA, 02110-1301 USA.

libs/vkd3d/Makefile.in

+EXTLIB    = libvkd3d.a
+EXTRAINCL = -I$(srcdir)/include -I$(srcdir)/include/private -I$(srcdir)/libs/vkd3d -I$(srcdir)/libs/vkd3d-shader
+EXTRADEFS = \
+	-DWINE_NO_NAMELESS_EXTENSION \
+	-DCONST_VTABLE \
+	-DLIBVKD3D_SOURCE \
+	-DLIBVKD3D_SHADER_SOURCE \
+	-DLIBVKD3D_UTILS_SOURCE
+
+SOURCES = \
+	libs/vkd3d-common/blob.c \
+	libs/vkd3d-common/debug.c \
+	libs/vkd3d-common/error.c \
+	libs/vkd3d-common/memory.c \
+	libs/vkd3d-common/utf8.c \
+	libs/vkd3d-shader/checksum.c \
+	libs/vkd3d-shader/d3dbc.c \
+	libs/vkd3d-shader/dxbc.c \
+	libs/vkd3d-shader/glsl.c \
+	libs/vkd3d-shader/hlsl.c \
+	libs/vkd3d-shader/hlsl.l \
+	libs/vkd3d-shader/hlsl.y \
+	libs/vkd3d-shader/hlsl_codegen.c \
+	libs/vkd3d-shader/hlsl_constant_ops.c \
+	libs/vkd3d-shader/hlsl_sm1.c \
+	libs/vkd3d-shader/hlsl_sm4.c \
+	libs/vkd3d-shader/preproc.l \
+	libs/vkd3d-shader/preproc.y \
+	libs/vkd3d-shader/spirv.c \
+	libs/vkd3d-shader/trace.c \
+	libs/vkd3d-shader/vkd3d_shader_main.c \
+	libs/vkd3d/command.c \
+	libs/vkd3d/device.c \
+	libs/vkd3d/resource.c \
+	libs/vkd3d/state.c \
+	libs/vkd3d/utils.c \
+	libs/vkd3d/vkd3d_main.c

libs/vkd3d/config.h

+#define PACKAGE_NAME "vkd3d"
+#define PACKAGE_STRING "vkd3d 1.3"
+#define PACKAGE_VERSION "1.3"
+#define PATH_MAX 1024
+#define SONAME_LIBVULKAN "vulkan-1.dll"

libs/vkd3d/include/private/vkd3d_blob.h

+/*
+ * Copyright 2017 Józef Kucia for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __VKD3D_BLOB_H
+#define __VKD3D_BLOB_H
+
+#include "windows.h"
+#include "d3dcommon.h"
+
+HRESULT vkd3d_blob_create(void *buffer, SIZE_T size, ID3D10Blob **blob);
+
+#endif  /* __VKD3D_BLOB_H */

libs/vkd3d/include/private/vkd3d_common.h

+/*
+ * Copyright 2016 Józef Kucia for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __VKD3D_COMMON_H
+#define __VKD3D_COMMON_H
+
+#include "config.h"
+#include "windows.h"
+#include "vkd3d_types.h"
+
+#include <ctype.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
+#ifndef ARRAY_SIZE
+# define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))
+#endif
+
+#define DIV_ROUND_UP(a, b) ((a) % (b) == 0 ? (a) / (b) : (a) / (b) + 1)
+
+#define STATIC_ASSERT(e) extern void __VKD3D_STATIC_ASSERT__(int [(e) ? 1 : -1])
+
+#define MEMBER_SIZE(t, m) sizeof(((t *)0)->m)
+
+#define VKD3D_MAKE_TAG(ch0, ch1, ch2, ch3) \
+        ((uint32_t)(ch0) | ((uint32_t)(ch1) << 8) \
+        | ((uint32_t)(ch2) << 16) | ((uint32_t)(ch3) << 24))
+
+static inline size_t align(size_t addr, size_t alignment)
+{
+    return (addr + (alignment - 1)) & ~(alignment - 1);
+}
+
+#ifdef __GNUC__
+# define VKD3D_NORETURN __attribute__((noreturn))
+# define VKD3D_PRINTF_FUNC(fmt, args) __attribute__((format(printf, fmt, args)))
+# define VKD3D_UNUSED __attribute__((unused))
+#else
+# define VKD3D_NORETURN
+# define VKD3D_PRINTF_FUNC(fmt, args)
+# define VKD3D_UNUSED
+#endif  /* __GNUC__ */
+
+static inline unsigned int vkd3d_popcount(unsigned int v)
+{
+#ifdef _MSC_VER
+    return __popcnt(v);
+#elif defined(__GNUC__) && (__GNUC__ >= 4)
+    return __builtin_popcount(v);
+#else
+    v -= (v >> 1) & 0x55555555;
+    v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
+    return (((v + (v >> 4)) & 0x0f0f0f0f) * 0x01010101) >> 24;
+#endif
+}
+
+static inline bool vkd3d_bitmask_is_contiguous(unsigned int mask)
+{
+    unsigned int i, j;
+
+    for (i = 0, j = 0; i < sizeof(mask) * CHAR_BIT; ++i)
+    {
+        if (mask & (1u << i))
+            ++j;
+        else if (j)
+            break;
+    }
+
+    return vkd3d_popcount(mask) == j;
+}
+
+/* Undefined for x == 0. */
+static inline unsigned int vkd3d_log2i(unsigned int x)
+{
+#ifdef _WIN32
+    /* _BitScanReverse returns the index of the highest set bit,
+     * unlike clz which is 31 - index. */
+    ULONG result;
+    _BitScanReverse(&result, x);
+    return (unsigned int)result;
+#elif defined(HAVE_BUILTIN_CLZ)
+    return __builtin_clz(x) ^ 0x1f;
+#else
+    static const unsigned int l[] =
+    {
+        ~0u, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
+          4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+          5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+          5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+          6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+          6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+          6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+          6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+    };
+    unsigned int i;
+
+    return (i = x >> 16) ? (x = i >> 8) ? l[x] + 24
+            : l[i] + 16 : (i = x >> 8) ? l[i] + 8 : l[x];
+#endif
+}
+
+static inline void *vkd3d_memmem( const void *haystack, size_t haystack_len, const void *needle, size_t needle_len)
+{
+    const char *str = haystack;
+
+    while (haystack_len >= needle_len)
+    {
+        if (!memcmp(str, needle, needle_len))
+            return (char *)str;
+        ++str;
+        --haystack_len;
+    }
+    return NULL;
+}
+
+static inline bool vkd3d_bound_range(size_t start, size_t count, size_t limit)
+{
+#ifdef HAVE_BUILTIN_ADD_OVERFLOW
+    size_t sum;
+
+    return !__builtin_add_overflow(start, count, &sum) && sum <= limit;
+#else
+    return start <= limit && count <= limit - start;
+#endif
+}
+
+static inline uint16_t vkd3d_make_u16(uint8_t low, uint8_t high)
+{
+    return low | ((uint16_t)high << 8);
+}
+
+static inline uint32_t vkd3d_make_u32(uint16_t low, uint16_t high)
+{
+    return low | ((uint32_t)high << 16);
+}
+
+static inline int vkd3d_u32_compare(uint32_t x, uint32_t y)
+{
+    return (x > y) - (x < y);
+}
+
+static inline int ascii_isupper(int c)
+{
+    return 'A' <= c && c <= 'Z';
+}
+
+static inline int ascii_tolower(int c)
+{
+    return ascii_isupper(c) ? c - 'A' + 'a' : c;
+}
+
+static inline int ascii_strncasecmp(const char *a, const char *b, size_t n)
+{
+    int c_a, c_b;
+
+    while (n--)
+    {
+        c_a = ascii_tolower(*a++);
+        c_b = ascii_tolower(*b++);
+        if (c_a != c_b || !c_a)
+            return c_a - c_b;
+    }
+    return 0;
+}
+
+static inline int ascii_strcasecmp(const char *a, const char *b)
+{
+    int c_a, c_b;
+
+    do
+    {
+        c_a = ascii_tolower(*a++);
+        c_b = ascii_tolower(*b++);
+    } while (c_a == c_b && c_a != '\0');
+
+    return c_a - c_b;
+}
+
+#ifndef _WIN32
+# if HAVE_SYNC_ADD_AND_FETCH
+static inline LONG InterlockedIncrement(LONG volatile *x)
+{
+    return __sync_add_and_fetch(x, 1);
+}
+static inline LONG InterlockedAdd(LONG volatile *x, LONG val)
+{
+    return __sync_add_and_fetch(x, val);
+}
+# else
+#  error "InterlockedIncrement() not implemented for this platform"
+# endif  /* HAVE_SYNC_ADD_AND_FETCH */
+
+# if HAVE_SYNC_SUB_AND_FETCH
+static inline LONG InterlockedDecrement(LONG volatile *x)
+{
+    return __sync_sub_and_fetch(x, 1);
+}
+# else
+#  error "InterlockedDecrement() not implemented for this platform"
+# endif
+#endif  /* _WIN32 */
+
+static inline void vkd3d_parse_version(const char *version, int *major, int *minor)
+{
+    *major = atoi(version);
+
+    while (isdigit(*version))
+        ++version;
+    if (*version == '.')
+        ++version;
+
+    *minor = atoi(version);
+}
+
+HRESULT hresult_from_vkd3d_result(int vkd3d_result);
+
+#endif  /* __VKD3D_COMMON_H */

libs/vkd3d/include/private/vkd3d_debug.h

+/*
+ * Copyright 2016 Józef Kucia for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __VKD3D_DEBUG_H
+#define __VKD3D_DEBUG_H
+
+#include "vkd3d_common.h"
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef VKD3D_NO_TRACE_MESSAGES
+#define TRACE(args...) do { } while (0)
+#define TRACE_ON() (false)
+#endif
+
+#ifdef VKD3D_NO_DEBUG_MESSAGES
+#define WARN(args...) do { } while (0)
+#define FIXME(args...) do { } while (0)
+#endif
+
+enum vkd3d_dbg_level
+{
+    VKD3D_DBG_LEVEL_NONE,
+    VKD3D_DBG_LEVEL_ERR,
+    VKD3D_DBG_LEVEL_FIXME,
+    VKD3D_DBG_LEVEL_WARN,
+    VKD3D_DBG_LEVEL_TRACE,
+};
+
+enum vkd3d_dbg_level vkd3d_dbg_get_level(void);
+
+void vkd3d_dbg_printf(enum vkd3d_dbg_level level, const char *function, const char *fmt, ...) VKD3D_PRINTF_FUNC(3, 4);
+
+const char *vkd3d_dbg_sprintf(const char *fmt, ...) VKD3D_PRINTF_FUNC(1, 2);
+const char *vkd3d_dbg_vsprintf(const char *fmt, va_list args);
+const char *debugstr_a(const char *str);
+const char *debugstr_an(const char *str, size_t n);
+const char *debugstr_w(const WCHAR *wstr, size_t wchar_size);
+
+#define VKD3D_DBG_LOG(level) \
+        do { \
+        const enum vkd3d_dbg_level vkd3d_dbg_level = VKD3D_DBG_LEVEL_##level; \
+        VKD3D_DBG_PRINTF
+
+#define VKD3D_DBG_LOG_ONCE(first_time_level, level) \
+        do { \
+        static bool vkd3d_dbg_next_time; \
+        const enum vkd3d_dbg_level vkd3d_dbg_level = vkd3d_dbg_next_time \
+        ? VKD3D_DBG_LEVEL_##level : VKD3D_DBG_LEVEL_##first_time_level; \
+        vkd3d_dbg_next_time = true; \
+        VKD3D_DBG_PRINTF
+
+#define VKD3D_DBG_PRINTF(...) \
+        vkd3d_dbg_printf(vkd3d_dbg_level, __FUNCTION__, __VA_ARGS__); } while (0)
+
+#ifndef TRACE
+#define TRACE VKD3D_DBG_LOG(TRACE)
+#endif
+
+#ifndef WARN
+#define WARN  VKD3D_DBG_LOG(WARN)
+#endif
+
+#ifndef FIXME
+#define FIXME VKD3D_DBG_LOG(FIXME)
+#endif
+
+#define ERR   VKD3D_DBG_LOG(ERR)
+
+#ifndef TRACE_ON
+#define TRACE_ON() (vkd3d_dbg_get_level() == VKD3D_DBG_LEVEL_TRACE)
+#endif
+
+#define FIXME_ONCE VKD3D_DBG_LOG_ONCE(FIXME, WARN)
+
+#define VKD3D_DEBUG_ENV_NAME(name) const char *vkd3d_dbg_env_name = name
+
+static inline const char *debugstr_guid(const GUID *guid)
+{
+    if (!guid)
+        return "(null)";
+
+    return vkd3d_dbg_sprintf("{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
+            (unsigned long)guid->Data1, guid->Data2, guid->Data3, guid->Data4[0],
+            guid->Data4[1], guid->Data4[2], guid->Data4[3], guid->Data4[4],
+            guid->Data4[5], guid->Data4[6], guid->Data4[7]);
+}
+
+unsigned int vkd3d_env_var_as_uint(const char *name, unsigned int default_value);
+
+struct vkd3d_debug_option
+{
+    const char *name;
+    uint64_t flag;
+};
+
+bool vkd3d_debug_list_has_member(const char *string, const char *member);
+uint64_t vkd3d_parse_debug_options(const char *string,
+        const struct vkd3d_debug_option *options, unsigned int option_count);
+
+#endif  /* __VKD3D_DEBUG_H */

libs/vkd3d/include/private/vkd3d_memory.h

+/*
+ * Copyright 2016 Józef Kucia for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __VKD3D_MEMORY_H
+#define __VKD3D_MEMORY_H
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "vkd3d_debug.h"
+
+static inline void *vkd3d_malloc(size_t size)
+{
+    void *ptr;
+    if (!(ptr = malloc(size)))
+        ERR("Out of memory.\n");
+    return ptr;
+}
+
+static inline void *vkd3d_realloc(void *ptr, size_t size)
+{
+    if (!(ptr = realloc(ptr, size)))
+        ERR("Out of memory, size %zu.\n", size);
+    return ptr;
+}
+
+static inline void *vkd3d_calloc(size_t count, size_t size)
+{
+    void *ptr;
+    assert(count <= ~(size_t)0 / size);
+    if (!(ptr = calloc(count, size)))
+        ERR("Out of memory.\n");
+    return ptr;
+}
+
+static inline void vkd3d_free(void *ptr)
+{
+    free(ptr);
+}
+
+static inline char *vkd3d_strdup(const char *string)
+{
+    size_t len = strlen(string) + 1;
+    char *ptr;
+
+    if ((ptr = vkd3d_malloc(len)))
+        memcpy(ptr, string, len);
+    return ptr;
+}
+
+bool vkd3d_array_reserve(void **elements, size_t *capacity, size_t element_count, size_t element_size);
+
+#endif  /* __VKD3D_MEMORY_H */

libs/vkd3d/include/private/vkd3d_utf8.h

+/*
+ * Copyright 2019 Zhiyi Zhang for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __VKD3D_UTF8_H
+#define __VKD3D_UTF8_H
+
+#include "vkd3d_common.h"
+
+char *vkd3d_strdup_w_utf8(const WCHAR *wstr, size_t wchar_size);
+
+#endif /* __VKD3D_UTF8_H */

libs/vkd3d/include/private/vkd3d_version.h

+#define VKD3D_VCS_ID " (git d773dc05c687)"

libs/vkd3d/include/vkd3d.h

+/*
+ * Copyright 2016 Józef Kucia for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __VKD3D_H
+#define __VKD3D_H
+
+#include <vkd3d_types.h>
+
+#ifndef VKD3D_NO_WIN32_TYPES
+# include <windows.h>
+# include <d3d12.h>
+#endif  /* VKD3D_NO_WIN32_TYPES */
+
+#ifndef VKD3D_NO_VULKAN_H
+# include <wine/vulkan.h>
+#endif  /* VKD3D_NO_VULKAN_H */
+
+#ifdef __cplusplus
+extern "C" {
+#endif  /* __cplusplus */
+
+enum vkd3d_structure_type
+{
+    /* 1.0 */
+    VKD3D_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+    VKD3D_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
+    VKD3D_STRUCTURE_TYPE_IMAGE_RESOURCE_CREATE_INFO,
+
+    /* 1.1 */
+    VKD3D_STRUCTURE_TYPE_OPTIONAL_INSTANCE_EXTENSIONS_INFO,
+
+    /* 1.2 */
+    VKD3D_STRUCTURE_TYPE_OPTIONAL_DEVICE_EXTENSIONS_INFO,
+    VKD3D_STRUCTURE_TYPE_APPLICATION_INFO,
+
+    /* 1.3 */
+    VKD3D_STRUCTURE_TYPE_HOST_TIME_DOMAIN_INFO,
+
+    VKD3D_FORCE_32_BIT_ENUM(VKD3D_STRUCTURE_TYPE),
+};
+
+enum vkd3d_api_version
+{
+    VKD3D_API_VERSION_1_0,
+    VKD3D_API_VERSION_1_1,
+    VKD3D_API_VERSION_1_2,
+    VKD3D_API_VERSION_1_3,
+};
+
+typedef HRESULT (*PFN_vkd3d_signal_event)(HANDLE event);
+
+typedef void * (*PFN_vkd3d_thread)(void *data);
+
+typedef void * (*PFN_vkd3d_create_thread)(PFN_vkd3d_thread thread_main, void *data);
+typedef HRESULT (*PFN_vkd3d_join_thread)(void *thread);
+
+struct vkd3d_instance;
+
+struct vkd3d_instance_create_info
+{
+    enum vkd3d_structure_type type;
+    const void *next;
+
+    PFN_vkd3d_signal_event pfn_signal_event;
+    PFN_vkd3d_create_thread pfn_create_thread;
+    PFN_vkd3d_join_thread pfn_join_thread;
+    size_t wchar_size;
+
+    /* If set to NULL, libvkd3d loads libvulkan. */
+    PFN_vkGetInstanceProcAddr pfn_vkGetInstanceProcAddr;
+
+    const char * const *instance_extensions;
+    uint32_t instance_extension_count;
+};
+
+/* Extends vkd3d_instance_create_info. Available since 1.1. */
+struct vkd3d_optional_instance_extensions_info
+{
+    enum vkd3d_structure_type type;
+    const void *next;
+
+    const char * const *extensions;
+    uint32_t extension_count;
+};
+
+/* Extends vkd3d_instance_create_info. Available since 1.2. */
+struct vkd3d_application_info
+{
+    enum vkd3d_structure_type type;
+    const void *next;
+
+    const char *application_name;
+    uint32_t application_version;
+
+    const char *engine_name; /* "vkd3d" if NULL */
+    uint32_t engine_version; /* vkd3d version if engine_name is NULL */
+
+    enum vkd3d_api_version api_version;
+};
+
+/* Extends vkd3d_instance_create_info. Available since 1.3. */
+struct vkd3d_host_time_domain_info
+{
+    enum vkd3d_structure_type type;
+    const void *next;
+
+    uint64_t ticks_per_second;
+};
+
+struct vkd3d_device_create_info
+{
+    enum vkd3d_structure_type type;
+    const void *next;
+
+    D3D_FEATURE_LEVEL minimum_feature_level;
+
+    struct vkd3d_instance *instance;
+    const struct vkd3d_instance_create_info *instance_create_info;
+
+    VkPhysicalDevice vk_physical_device;
+
+    const char * const *device_extensions;
+    uint32_t device_extension_count;
+
+    IUnknown *parent;
+    LUID adapter_luid;
+};
+
+/* Extends vkd3d_device_create_info. Available since 1.2. */
+struct vkd3d_optional_device_extensions_info
+{
+    enum vkd3d_structure_type type;
+    const void *next;
+
+    const char * const *extensions;
+    uint32_t extension_count;
+};
+
+/* vkd3d_image_resource_create_info flags */
+#define VKD3D_RESOURCE_INITIAL_STATE_TRANSITION 0x00000001
+#define VKD3D_RESOURCE_PRESENT_STATE_TRANSITION 0x00000002
+
+struct vkd3d_image_resource_create_info
+{
+    enum vkd3d_structure_type type;
+    const void *next;
+
+    VkImage vk_image;
+    D3D12_RESOURCE_DESC desc;
+    unsigned int flags;
+    D3D12_RESOURCE_STATES present_state;
+};
+
+#ifdef LIBVKD3D_SOURCE
+# define VKD3D_API VKD3D_EXPORT
+#else
+# define VKD3D_API VKD3D_IMPORT
+#endif
+
+#ifndef VKD3D_NO_PROTOTYPES
+
+VKD3D_API HRESULT vkd3d_create_instance(const struct vkd3d_instance_create_info *create_info,
+        struct vkd3d_instance **instance);
+VKD3D_API ULONG vkd3d_instance_decref(struct vkd3d_instance *instance);
+VKD3D_API VkInstance vkd3d_instance_get_vk_instance(struct vkd3d_instance *instance);
+VKD3D_API ULONG vkd3d_instance_incref(struct vkd3d_instance *instance);
+
+VKD3D_API HRESULT vkd3d_create_device(const struct vkd3d_device_create_info *create_info,
+        REFIID iid, void **device);
+VKD3D_API IUnknown *vkd3d_get_device_parent(ID3D12Device *device);
+VKD3D_API VkDevice vkd3d_get_vk_device(ID3D12Device *device);
+VKD3D_API VkPhysicalDevice vkd3d_get_vk_physical_device(ID3D12Device *device);
+VKD3D_API struct vkd3d_instance *vkd3d_instance_from_device(ID3D12Device *device);
+
+VKD3D_API uint32_t vkd3d_get_vk_queue_family_index(ID3D12CommandQueue *queue);
+VKD3D_API VkQueue vkd3d_acquire_vk_queue(ID3D12CommandQueue *queue);
+VKD3D_API void vkd3d_release_vk_queue(ID3D12CommandQueue *queue);
+
+VKD3D_API HRESULT vkd3d_create_image_resource(ID3D12Device *device,
+        const struct vkd3d_image_resource_create_info *create_info, ID3D12Resource **resource);
+VKD3D_API ULONG vkd3d_resource_decref(ID3D12Resource *resource);
+VKD3D_API ULONG vkd3d_resource_incref(ID3D12Resource *resource);
+
+VKD3D_API HRESULT vkd3d_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *desc,
+        D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob);
+VKD3D_API HRESULT vkd3d_create_root_signature_deserializer(const void *data, SIZE_T data_size,
+        REFIID iid, void **deserializer);
+
+VKD3D_API VkFormat vkd3d_get_vk_format(DXGI_FORMAT format);
+
+/* 1.1 */
+VKD3D_API DXGI_FORMAT vkd3d_get_dxgi_format(VkFormat format);
+
+/* 1.2 */
+VKD3D_API HRESULT vkd3d_serialize_versioned_root_signature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc,
+        ID3DBlob **blob, ID3DBlob **error_blob);
+VKD3D_API HRESULT vkd3d_create_versioned_root_signature_deserializer(const void *data, SIZE_T data_size,
+        REFIID iid, void **deserializer);
+
+#endif  /* VKD3D_NO_PROTOTYPES */
+
+/*
+ * Function pointer typedefs for vkd3d functions.
+ */
+typedef HRESULT (*PFN_vkd3d_create_instance)(const struct vkd3d_instance_create_info *create_info,
+        struct vkd3d_instance **instance);
+typedef ULONG (*PFN_vkd3d_instance_decref)(struct vkd3d_instance *instance);
+typedef VkInstance (*PFN_vkd3d_instance_get_vk_instance)(struct vkd3d_instance *instance);
+typedef ULONG (*PFN_vkd3d_instance_incref)(struct vkd3d_instance *instance);
+
+typedef HRESULT (*PFN_vkd3d_create_device)(const struct vkd3d_device_create_info *create_info,
+        REFIID iid, void **device);
+typedef IUnknown * (*PFN_vkd3d_get_device_parent)(ID3D12Device *device);
+typedef VkDevice (*PFN_vkd3d_get_vk_device)(ID3D12Device *device);
+typedef VkPhysicalDevice (*PFN_vkd3d_get_vk_physical_device)(ID3D12Device *device);
+typedef struct vkd3d_instance * (*PFN_vkd3d_instance_from_device)(ID3D12Device *device);
+
+typedef uint32_t (*PFN_vkd3d_get_vk_queue_family_index)(ID3D12CommandQueue *queue);
+typedef VkQueue (*PFN_vkd3d_acquire_vk_queue)(ID3D12CommandQueue *queue);
+typedef void (*PFN_vkd3d_release_vk_queue)(ID3D12CommandQueue *queue);
+
+typedef HRESULT (*PFN_vkd3d_create_image_resource)(ID3D12Device *device,
+        const struct vkd3d_image_resource_create_info *create_info, ID3D12Resource **resource);
+typedef ULONG (*PFN_vkd3d_resource_decref)(ID3D12Resource *resource);
+typedef ULONG (*PFN_vkd3d_resource_incref)(ID3D12Resource *resource);
+
+typedef HRESULT (*PFN_vkd3d_serialize_root_signature)(const D3D12_ROOT_SIGNATURE_DESC *desc,
+        D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob);
+typedef HRESULT (*PFN_vkd3d_create_root_signature_deserializer)(const void *data, SIZE_T data_size,
+        REFIID iid, void **deserializer);
+
+typedef VkFormat (*PFN_vkd3d_get_vk_format)(DXGI_FORMAT format);
+
+/* 1.1 */
+typedef DXGI_FORMAT (*PFN_vkd3d_get_dxgi_format)(VkFormat format);
+
+/* 1.2 */
+typedef HRESULT (*PFN_vkd3d_serialize_versioned_root_signature)(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc,
+        ID3DBlob **blob, ID3DBlob **error_blob);
+typedef HRESULT (*PFN_vkd3d_create_versioned_root_signature_deserializer)(const void *data, SIZE_T data_size,
+        REFIID iid, void **deserializer);
+
+#ifdef __cplusplus
+}
+#endif  /* __cplusplus */
+
+#endif  /* __VKD3D_H */

libs/vkd3d/include/vkd3d_types.h

+/*
+ * Copyright 2016-2018 Józef Kucia for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __VKD3D_TYPES_H
+#define __VKD3D_TYPES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif  /* __cplusplus */
+
+/**
+ * \file vkd3d_types.h
+ *
+ * This file contains definitions for basic types used by vkd3d libraries.
+ */
+
+#define VKD3D_FORCE_32_BIT_ENUM(name) name##_FORCE_32BIT = 0x7fffffff
+
+/**
+ * Result codes returned by some vkd3d functions. Error codes always have
+ * negative values; non-error codes never do.
+ */
+enum vkd3d_result
+{
+    /** Success. */
+    VKD3D_OK = 0,
+    /** An unspecified failure occurred. */
+    VKD3D_ERROR = -1,
+    /** There are not enough resources available to complete the operation. */
+    VKD3D_ERROR_OUT_OF_MEMORY = -2,
+    /** One or more parameters passed to a vkd3d function were invalid. */
+    VKD3D_ERROR_INVALID_ARGUMENT = -3,
+    /** A shader passed to a vkd3d function was invalid. */
+    VKD3D_ERROR_INVALID_SHADER = -4,
+    /** The operation is not implemented in this version of vkd3d. */
+    VKD3D_ERROR_NOT_IMPLEMENTED = -5,
+
+    VKD3D_FORCE_32_BIT_ENUM(VKD3D_RESULT),
+};
+
+#ifdef _WIN32
+# define VKD3D_IMPORT
+# define VKD3D_EXPORT
+#elif defined(__GNUC__)
+# define VKD3D_IMPORT
+# define VKD3D_EXPORT __attribute__((visibility("default")))
+#else
+# define VKD3D_IMPORT
+# define VKD3D_EXPORT
+#endif
+
+#ifdef __cplusplus
+}
+#endif  /* __cplusplus */
+
+#endif  /* __VKD3D_TYPES_H */

libs/vkd3d/include/vulkan/GLSL.std.450.h

+/*
+** Copyright (c) 2014-2016 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and/or associated documentation files (the "Materials"),
+** to deal in the Materials without restriction, including without limitation
+** the rights to use, copy, modify, merge, publish, distribute, sublicense,
+** and/or sell copies of the Materials, and to permit persons to whom the
+** Materials are furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Materials.
+**
+** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+** IN THE MATERIALS.
+*/
+
+#ifndef GLSLstd450_H
+#define GLSLstd450_H
+
+static const int GLSLstd450Version = 100;
+static const int GLSLstd450Revision = 3;
+
+enum GLSLstd450 {
+    GLSLstd450Bad = 0,              // Don't use
+
+    GLSLstd450Round = 1,
+    GLSLstd450RoundEven = 2,
+    GLSLstd450Trunc = 3,
+    GLSLstd450FAbs = 4,
+    GLSLstd450SAbs = 5,
+    GLSLstd450FSign = 6,
+    GLSLstd450SSign = 7,
+    GLSLstd450Floor = 8,
+    GLSLstd450Ceil = 9,
+    GLSLstd450Fract = 10,
+
+    GLSLstd450Radians = 11,
+    GLSLstd450Degrees = 12,
+    GLSLstd450Sin = 13,
+    GLSLstd450Cos = 14,
+    GLSLstd450Tan = 15,
+    GLSLstd450Asin = 16,
+    GLSLstd450Acos = 17,
+    GLSLstd450Atan = 18,
+    GLSLstd450Sinh = 19,
+    GLSLstd450Cosh = 20,
+    GLSLstd450Tanh = 21,
+    GLSLstd450Asinh = 22,
+    GLSLstd450Acosh = 23,
+    GLSLstd450Atanh = 24,
+    GLSLstd450Atan2 = 25,
+
+    GLSLstd450Pow = 26,
+    GLSLstd450Exp = 27,
+    GLSLstd450Log = 28,
+    GLSLstd450Exp2 = 29,
+    GLSLstd450Log2 = 30,
+    GLSLstd450Sqrt = 31,
+    GLSLstd450InverseSqrt = 32,
+
+    GLSLstd450Determinant = 33,
+    GLSLstd450MatrixInverse = 34,
+
+    GLSLstd450Modf = 35,            // second operand needs an OpVariable to write to
+    GLSLstd450ModfStruct = 36,      // no OpVariable operand
+    GLSLstd450FMin = 37,
+    GLSLstd450UMin = 38,
+    GLSLstd450SMin = 39,
+    GLSLstd450FMax = 40,
+    GLSLstd450UMax = 41,
+    GLSLstd450SMax = 42,
+    GLSLstd450FClamp = 43,
+    GLSLstd450UClamp = 44,
+    GLSLstd450SClamp = 45,
+    GLSLstd450FMix = 46,
+    GLSLstd450IMix = 47,            // Reserved
+    GLSLstd450Step = 48,
+    GLSLstd450SmoothStep = 49,
+
+    GLSLstd450Fma = 50,
+    GLSLstd450Frexp = 51,            // second operand needs an OpVariable to write to
+    GLSLstd450FrexpStruct = 52,      // no OpVariable operand
+    GLSLstd450Ldexp = 53,
+
+    GLSLstd450PackSnorm4x8 = 54,
+    GLSLstd450PackUnorm4x8 = 55,
+    GLSLstd450PackSnorm2x16 = 56,
+    GLSLstd450PackUnorm2x16 = 57,
+    GLSLstd450PackHalf2x16 = 58,
+    GLSLstd450PackDouble2x32 = 59,
+    GLSLstd450UnpackSnorm2x16 = 60,
+    GLSLstd450UnpackUnorm2x16 = 61,
+    GLSLstd450UnpackHalf2x16 = 62,
+    GLSLstd450UnpackSnorm4x8 = 63,
+    GLSLstd450UnpackUnorm4x8 = 64,
+    GLSLstd450UnpackDouble2x32 = 65,
+
+    GLSLstd450Length = 66,
+    GLSLstd450Distance = 67,
+    GLSLstd450Cross = 68,
+    GLSLstd450Normalize = 69,
+    GLSLstd450FaceForward = 70,
+    GLSLstd450Reflect = 71,
+    GLSLstd450Refract = 72,
+
+    GLSLstd450FindILsb = 73,
+    GLSLstd450FindSMsb = 74,
+    GLSLstd450FindUMsb = 75,
+
+    GLSLstd450InterpolateAtCentroid = 76,
+    GLSLstd450InterpolateAtSample = 77,
+    GLSLstd450InterpolateAtOffset = 78,
+
+    GLSLstd450NMin = 79,
+    GLSLstd450NMax = 80,
+    GLSLstd450NClamp = 81,
+
+    GLSLstd450Count
+};
+
+#endif  // #ifndef GLSLstd450_H

libs/vkd3d/libs/vkd3d-common/blob.c

+/*
+ * Copyright 2017 Józef Kucia for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define COBJMACROS
+#include "vkd3d.h"
+#include "vkd3d_blob.h"
+#include "vkd3d_debug.h"
+#include "vkd3d_memory.h"
+
+struct vkd3d_blob
+{
+    ID3D10Blob ID3DBlob_iface;
+    LONG refcount;
+
+    void *buffer;
+    SIZE_T size;
+};
+
+static struct vkd3d_blob *impl_from_ID3DBlob(ID3DBlob *iface)
+{
+    return CONTAINING_RECORD(iface, struct vkd3d_blob, ID3DBlob_iface);
+}
+
+static HRESULT STDMETHODCALLTYPE vkd3d_blob_QueryInterface(ID3DBlob *iface, REFIID riid, void **object)
+{
+    TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
+
+    if (IsEqualGUID(riid, &IID_ID3DBlob)
+            || IsEqualGUID(riid, &IID_IUnknown))
+    {
+        ID3D10Blob_AddRef(iface);
+        *object = iface;
+        return S_OK;
+    }
+
+    WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
+
+    *object = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG STDMETHODCALLTYPE vkd3d_blob_AddRef(ID3DBlob *iface)
+{
+    struct vkd3d_blob *blob = impl_from_ID3DBlob(iface);
+    ULONG refcount = InterlockedIncrement(&blob->refcount);
+
+    TRACE("%p increasing refcount to %u.\n", blob, refcount);
+
+    return refcount;
+}
+
+static ULONG STDMETHODCALLTYPE vkd3d_blob_Release(ID3DBlob *iface)
+{
+    struct vkd3d_blob *blob = impl_from_ID3DBlob(iface);
+    ULONG refcount = InterlockedDecrement(&blob->refcount);
+
+    TRACE("%p decreasing refcount to %u.\n", blob, refcount);
+
+    if (!refcount)
+    {
+        vkd3d_free(blob->buffer);
+
+        vkd3d_free(blob);
+    }
+
+    return refcount;
+}
+
+static void * STDMETHODCALLTYPE vkd3d_blob_GetBufferPointer(ID3DBlob *iface)
+{
+    struct vkd3d_blob *blob = impl_from_ID3DBlob(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return blob->buffer;
+}
+
+static SIZE_T STDMETHODCALLTYPE vkd3d_blob_GetBufferSize(ID3DBlob *iface)
+{
+    struct vkd3d_blob *blob = impl_from_ID3DBlob(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return blob->size;
+}
+
+static const struct ID3D10BlobVtbl vkd3d_blob_vtbl =
+{
+    /* IUnknown methods */
+    vkd3d_blob_QueryInterface,
+    vkd3d_blob_AddRef,
+    vkd3d_blob_Release,
+    /* ID3DBlob methods */
+    vkd3d_blob_GetBufferPointer,
+    vkd3d_blob_GetBufferSize
+};
+
+static void vkd3d_blob_init(struct vkd3d_blob *blob, void *buffer, SIZE_T size)
+{
+    blob->ID3DBlob_iface.lpVtbl = &vkd3d_blob_vtbl;
+    blob->refcount = 1;
+
+    blob->buffer = buffer;
+    blob->size = size;
+}
+
+HRESULT vkd3d_blob_create(void *buffer, SIZE_T size, ID3D10Blob **blob)
+{
+    struct vkd3d_blob *object;
+
+    if (!(object = vkd3d_malloc(sizeof(*object))))
+        return E_OUTOFMEMORY;
+
+    vkd3d_blob_init(object, buffer, size);
+
+    TRACE("Created blob object %p.\n", object);
+
+    *blob = &object->ID3DBlob_iface;
+
+    return S_OK;
+}

libs/vkd3d/libs/vkd3d-common/debug.c

+/*
+ * Copyright 2016 Józef Kucia for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "vkd3d_debug.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+
+#define VKD3D_DEBUG_BUFFER_COUNT 64
+#define VKD3D_DEBUG_BUFFER_SIZE 512
+
+extern const char *vkd3d_dbg_env_name;
+
+static const char *debug_level_names[] =
+{
+    /* VKD3D_DBG_LEVEL_NONE  */ "none",
+    /* VKD3D_DBG_LEVEL_ERR   */ "err",
+    /* VKD3D_DBG_LEVEL_FIXME */ "fixme",
+    /* VKD3D_DBG_LEVEL_WARN  */ "warn",
+    /* VKD3D_DBG_LEVEL_TRACE */ "trace",
+};
+
+enum vkd3d_dbg_level vkd3d_dbg_get_level(void)
+{
+    static unsigned int level = ~0u;
+    const char *vkd3d_debug;
+    unsigned int i;
+
+    if (level != ~0u)
+        return level;
+
+    if (!(vkd3d_debug = getenv(vkd3d_dbg_env_name)))
+        vkd3d_debug = "";
+
+    for (i = 0; i < ARRAY_SIZE(debug_level_names); ++i)
+    {
+        if (!strcmp(debug_level_names[i], vkd3d_debug))
+        {
+            level = i;
+            return level;
+        }
+    }
+
+    /* Default debug level. */
+    level = VKD3D_DBG_LEVEL_FIXME;
+    return level;
+}
+
+void vkd3d_dbg_printf(enum vkd3d_dbg_level level, const char *function, const char *fmt, ...)
+{
+    va_list args;
+
+    if (vkd3d_dbg_get_level() < level)
+        return;
+
+    assert(level < ARRAY_SIZE(debug_level_names));
+
+    fprintf(stderr, "%s:%s: ", debug_level_names[level], function);
+    va_start(args, fmt);
+    vfprintf(stderr, fmt, args);
+    va_end(args);
+}
+
+static char *get_buffer(void)
+{
+    static char buffers[VKD3D_DEBUG_BUFFER_COUNT][VKD3D_DEBUG_BUFFER_SIZE];
+    static LONG buffer_index;
+    LONG current_index;
+
+    current_index = InterlockedIncrement(&buffer_index) % ARRAY_SIZE(buffers);
+    return buffers[current_index];
+}
+
+const char *vkd3d_dbg_vsprintf(const char *fmt, va_list args)
+{
+    char *buffer;
+
+    buffer = get_buffer();
+    vsnprintf(buffer, VKD3D_DEBUG_BUFFER_SIZE, fmt, args);
+    buffer[VKD3D_DEBUG_BUFFER_SIZE - 1] = '\0';
+    return buffer;
+}
+
+const char *vkd3d_dbg_sprintf(const char *fmt, ...)
+{
+    const char *buffer;
+    va_list args;
+
+    va_start(args, fmt);
+    buffer = vkd3d_dbg_vsprintf(fmt, args);
+    va_end(args);
+    return buffer;
+}
+
+static int get_escape_char(int c)
+{
+    switch (c)
+    {
+        case '"':
+        case '\\':
+            return c;
+        case '\t':
+            return 't';
+        case '\n':
+            return 'n';
+        case '\r':
+            return 'r';
+        default:
+            return 0;
+    }
+}
+
+const char *debugstr_an(const char *str, size_t n)
+{
+    char *buffer, *ptr;
+    int escape_char;
+    char c;
+
+    if (!str)
+        return "(null)";
+    if (n == SIZE_MAX)
+        n = strlen(str);
+
+    ptr = buffer = get_buffer();
+
+    *ptr++ = '"';
+    while (n-- && ptr <= buffer + VKD3D_DEBUG_BUFFER_SIZE - 8)
+    {
+        c = *str++;
+
+        if ((escape_char = get_escape_char(c)))
+        {
+            *ptr++ = '\\';
+            *ptr++ = escape_char;
+            continue;
+        }
+
+        if (isprint(c))
+        {
+            *ptr++ = c;
+        }
+        else
+        {
+            *ptr++ = '\\';
+            sprintf(ptr, "%02x", c);
+            ptr += 2;
+        }
+    }
+    *ptr++ = '"';
+
+    if (++n)
+    {
+        *ptr++ = '.';
+        *ptr++ = '.';
+        *ptr++ = '.';
+    }
+    *ptr = '\0';
+
+    return buffer;
+}
+
+const char *debugstr_a(const char *str)
+{
+    return debugstr_an(str, SIZE_MAX);
+}
+
+static const char *debugstr_w16(const uint16_t *wstr)
+{
+    char *buffer, *ptr;
+    uint16_t c;
+
+    if (!wstr)
+        return "(null)";
+
+    ptr = buffer = get_buffer();
+
+    *ptr++ = '"';
+    while ((c = *wstr++) && ptr <= buffer + VKD3D_DEBUG_BUFFER_SIZE - 10)
+    {
+        int escape_char = get_escape_char(c);
+
+        if (escape_char)
+        {
+            *ptr++ = '\\';
+            *ptr++ = escape_char;
+            continue;
+        }
+
+        if (isprint(c))
+        {
+            *ptr++ = c;
+        }
+        else
+        {
+            *ptr++ = '\\';
+            sprintf(ptr, "%04x", c);
+            ptr += 4;
+        }
+    }
+    *ptr++ = '"';
+
+    if (c)
+    {
+        *ptr++ = '.';
+        *ptr++ = '.';
+        *ptr++ = '.';
+    }
+    *ptr = '\0';
+
+    return buffer;
+}
+
+static const char *debugstr_w32(const uint32_t *wstr)
+{
+    char *buffer, *ptr;
+    uint32_t c;
+
+    if (!wstr)
+        return "(null)";
+
+    ptr = buffer = get_buffer();
+
+    *ptr++ = '"';
+    while ((c = *wstr++) && ptr <= buffer + VKD3D_DEBUG_BUFFER_SIZE - 10)
+    {
+        int escape_char = get_escape_char(c);
+
+        if (escape_char)
+        {
+            *ptr++ = '\\';
+            *ptr++ = escape_char;
+            continue;
+        }
+
+        if (isprint(c))
+        {
+            *ptr++ = c;
+        }
+        else
+        {
+            *ptr++ = '\\';
+            sprintf(ptr, "%04x", c);
+            ptr += 4;
+        }
+    }
+    *ptr++ = '"';
+
+    if (c)
+    {
+        *ptr++ = '.';
+        *ptr++ = '.';
+        *ptr++ = '.';
+    }
+    *ptr = '\0';
+
+    return buffer;
+}
+
+const char *debugstr_w(const WCHAR *wstr, size_t wchar_size)
+{
+    if (wchar_size == 2)
+        return debugstr_w16((const uint16_t *)wstr);
+    return debugstr_w32((const uint32_t *)wstr);
+}
+
+unsigned int vkd3d_env_var_as_uint(const char *name, unsigned int default_value)
+{
+    const char *value = getenv(name);
+    unsigned long r;
+    char *end_ptr;
+
+    if (value)
+    {
+        errno = 0;
+        r = strtoul(value, &end_ptr, 0);
+        if (!errno && end_ptr != value)
+            return min(r, UINT_MAX);
+    }
+
+    return default_value;
+}
+
+static bool is_option_separator(char c)
+{
+    return c == ',' || c == ';' || c == '\0';
+}
+
+bool vkd3d_debug_list_has_member(const char *string, const char *member)
+{
+    char prev_char, next_char;
+    const char *p;
+
+    p = string;
+    while (p)
+    {
+        if ((p = strstr(p, member)))
+        {
+            prev_char = p > string ? p[-1] : 0;
+            p += strlen(member);
+            next_char = *p;
+
+            if (is_option_separator(prev_char) && is_option_separator(next_char))
+                return true;
+        }
+    }
+
+    return false;
+}
+
+uint64_t vkd3d_parse_debug_options(const char *string,
+        const struct vkd3d_debug_option *options, unsigned int option_count)
+{
+    uint64_t flags = 0;
+    unsigned int i;
+
+    for (i = 0; i < option_count; ++i)
+    {
+        const struct vkd3d_debug_option *opt = &options[i];
+
+        if (vkd3d_debug_list_has_member(string, opt->name))
+            flags |= opt->flag;
+    }
+
+    return flags;
+}

libs/vkd3d/libs/vkd3d-common/error.c

+/*
+ * Copyright 2018 Józef Kucia for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "vkd3d_common.h"
+#include "vkd3d_debug.h"
+
+HRESULT hresult_from_vkd3d_result(int vkd3d_result)
+{
+    switch (vkd3d_result)
+    {
+        case VKD3D_OK:
+            return S_OK;
+        case VKD3D_ERROR_INVALID_SHADER:
+            WARN("Invalid shader bytecode.\n");
+            /* fall-through */
+        case VKD3D_ERROR:
+            return E_FAIL;
+        case VKD3D_ERROR_OUT_OF_MEMORY:
+            return E_OUTOFMEMORY;
+        case VKD3D_ERROR_INVALID_ARGUMENT:
+            return E_INVALIDARG;
+        case VKD3D_ERROR_NOT_IMPLEMENTED:
+            return E_NOTIMPL;
+        default:
+            FIXME("Unhandled vkd3d result %d.\n", vkd3d_result);
+            return E_FAIL;
+    }
+}

libs/vkd3d/libs/vkd3d-common/memory.c

+/*
+ * Copyright 2016 Henri Verbeet for CodeWeavers
+ * Copyright 2017 Józef Kucia for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "vkd3d_memory.h"
+
+bool vkd3d_array_reserve(void **elements, size_t *capacity, size_t element_count, size_t element_size)
+{
+    size_t new_capacity, max_capacity;
+    void *new_elements;
+
+    if (element_count <= *capacity)
+        return true;
+
+    max_capacity = ~(size_t)0 / element_size;
+    if (max_capacity < element_count)
+        return false;
+
+    new_capacity = max(*capacity, 4);
+    while (new_capacity < element_count && new_capacity <= max_capacity / 2)
+        new_capacity *= 2;
+
+    if (new_capacity < element_count)
+        new_capacity = element_count;
+
+    if (!(new_elements = vkd3d_realloc(*elements, new_capacity * element_size)))
+        return false;
+
+    *elements = new_elements;
+    *capacity = new_capacity;
+
+    return true;
+}

libs/vkd3d/libs/vkd3d-common/utf8.c

+/*
+ * Copyright 2000 Alexandre Julliard
+ * Copyright 2019 Zhiyi Zhang for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "vkd3d_memory.h"
+#include "vkd3d_utf8.h"
+
+#include <inttypes.h>
+
+static size_t vkd3d_utf8_len(uint32_t c)
+{
+    /* 0x00-0x7f: 1 byte */
+    if (c < 0x80)
+        return 1;
+    /* 0x80-0x7ff: 2 bytes */
+    if (c < 0x800)
+        return 2;
+    /* 0x800-0xffff: 3 bytes */
+    if (c < 0x10000)
+        return 3;
+    /* 0x10000-0x10ffff: 4 bytes */
+    return 4;
+}
+
+static void vkd3d_utf8_append(char **dst, uint32_t c)
+{
+    char *d = *dst;
+
+    /* 0x00-0x7f: 1 byte */
+    if (c < 0x80)
+    {
+        d[0] = c;
+        *dst += 1;
+        return;
+    }
+
+    /* 0x80-0x7ff: 2 bytes */
+    if (c < 0x800)
+    {
+        d[1] = 0x80 | (c & 0x3f);
+        c >>= 6;
+        d[0] = 0xc0 | c;
+        *dst += 2;
+        return;
+    }
+
+    /* 0x800-0xffff: 3 bytes */
+    if (c < 0x10000)  /* 0x800-0xffff: 3 bytes */
+    {
+        d[2] = 0x80 | (c & 0x3f);
+        c >>= 6;
+        d[1] = 0x80 | (c & 0x3f);
+        c >>= 6;
+        d[0] = 0xe0 | c;
+        *dst += 3;
+        return;
+    }
+
+    /* 0x10000-0x10ffff: 4 bytes */
+    d[3] = 0x80 | (c & 0x3f);
+    c >>= 6;
+    d[2] = 0x80 | (c & 0x3f);
+    c >>= 6;
+    d[1] = 0x80 | (c & 0x3f);
+    c >>= 6;
+    d[0] = 0xf0 | c;
+    *dst += 4;
+}
+
+static uint32_t vkd3d_utf16_read(const uint16_t **src)
+{
+    const uint16_t *s = *src;
+
+    if (s[0] < 0xd800 || s[0] > 0xdfff) /* Not a surrogate pair. */
+    {
+        *src += 1;
+        return s[0];
+    }
+
+    if (s[0] > 0xdbff /* Invalid high surrogate. */
+            || s[1] < 0xdc00 || s[1] > 0xdfff) /* Invalid low surrogate. */
+    {
+        *src += 1;
+        return 0;
+    }
+
+    *src += 2;
+    return 0x10000 + ((s[0] & 0x3ff) << 10) + (s[1] & 0x3ff);
+}
+
+static char *vkd3d_strdup_w16_utf8(const uint16_t *wstr)
+{
+    const uint16_t *src = wstr;
+    size_t dst_size = 0;
+    char *dst, *utf8;
+    uint32_t c;
+
+    while (*src)
+    {
+        if (!(c = vkd3d_utf16_read(&src)))
+            continue;
+        dst_size += vkd3d_utf8_len(c);
+    }
+    ++dst_size;
+
+    if (!(dst = vkd3d_malloc(dst_size)))
+        return NULL;
+
+    utf8 = dst;
+    src = wstr;
+    while (*src)
+    {
+        if (!(c = vkd3d_utf16_read(&src)))
+            continue;
+        vkd3d_utf8_append(&utf8, c);
+    }
+    *utf8 = 0;
+
+    return dst;
+}
+
+static char *vkd3d_strdup_w32_utf8(const uint32_t *wstr)
+{
+    const uint32_t *src = wstr;
+    size_t dst_size = 0;
+    char *dst, *utf8;
+
+    while (*src)
+        dst_size += vkd3d_utf8_len(*src++);
+    ++dst_size;
+
+    if (!(dst = vkd3d_malloc(dst_size)))
+        return NULL;
+
+    utf8 = dst;
+    src = wstr;
+    while (*src)
+        vkd3d_utf8_append(&utf8, *src++);
+    *utf8 = 0;
+
+    return dst;
+}
+
+char *vkd3d_strdup_w_utf8(const WCHAR *wstr, size_t wchar_size)
+{
+    if (wchar_size == 2)
+        return vkd3d_strdup_w16_utf8((const uint16_t *)wstr);
+    return vkd3d_strdup_w32_utf8((const uint32_t *)wstr);
+}

libs/vkd3d/libs/vkd3d-shader/checksum.c

+/*
+ * Copyright (C) 2001 Nikos Mavroyanopoulos
+ * Copyright (C) 2004 Hans Leidekker
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+/*
+ * This code implements the MD5 message-digest algorithm.
+ * It is based on code in the public domain written by Colin
+ * Plumb in 1993. The algorithm is due to Ron Rivest.
+ *
+ * Equivalent code is available from RSA Data Security, Inc.
+ * This code has been tested against that, and is equivalent,
+ * except that you don't need to include two pages of legalese
+ * with every copy.
+ *
+ * To compute the message digest of a chunk of bytes, declare an
+ * md5_ctx structure, pass it to md5_init, call md5_update as
+ * needed on buffers full of bytes, and then call md5_final, which
+ * will fill a supplied 16-byte array with the digest.
+ */
+
+#include "vkd3d_shader_private.h"
+
+#define DXBC_CHECKSUM_BLOCK_SIZE 64
+
+STATIC_ASSERT(sizeof(unsigned int) == 4);
+
+struct md5_ctx
+{
+    unsigned int i[2];
+    unsigned int buf[4];
+    unsigned char in[DXBC_CHECKSUM_BLOCK_SIZE];
+    unsigned char digest[16];
+};
+
+/* The four core functions - F1 is optimized somewhat */
+
+/* #define F1(x, y, z) (x & y | ~x & z) */
+#define F1(x, y, z) (z ^ (x & (y ^ z)))
+#define F2(x, y, z) F1(z, x, y)
+#define F3(x, y, z) (x ^ y ^ z)
+#define F4(x, y, z) (y ^ (x | ~z))
+
+/* This is the central step in the MD5 algorithm. */
+#define MD5STEP(f, w, x, y, z, data, s) \
+        (w += f(x, y, z) + data,  w = w << s | w >> (32 - s),  w += x)
+
+/*
+ * The core of the MD5 algorithm, this alters an existing MD5 hash to
+ * reflect the addition of 16 longwords of new data. md5_update blocks
+ * the data and converts bytes into longwords for this routine.
+ */
+static void md5_transform(unsigned int buf[4], const unsigned int in[16])
+{
+    unsigned int a, b, c, d;
+
+    a = buf[0];
+    b = buf[1];
+    c = buf[2];
+    d = buf[3];
+
+    MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
+    MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
+    MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
+    MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
+    MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
+    MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
+    MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
+    MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
+    MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
+    MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
+    MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
+    MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
+    MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
+    MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
+    MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
+    MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
+
+    MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
+    MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
+    MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
+    MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
+    MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
+    MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
+    MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
+    MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
+    MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
+    MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
+    MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
+    MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
+    MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
+    MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
+    MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
+    MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
+
+    MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
+    MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
+    MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
+    MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
+    MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
+    MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
+    MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
+    MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
+    MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
+    MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
+    MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
+    MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
+    MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
+    MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
+    MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
+    MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
+
+    MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
+    MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
+    MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
+    MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
+    MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
+    MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
+    MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
+    MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
+    MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
+    MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
+    MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
+    MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
+    MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
+    MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
+    MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
+    MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
+
+    buf[0] += a;
+    buf[1] += b;
+    buf[2] += c;
+    buf[3] += d;
+}
+
+/*
+ * Note: this code is harmless on little-endian machines.
+ */
+static void byte_reverse(unsigned char *buf, unsigned longs)
+{
+    unsigned int t;
+
+    do
+    {
+        t = vkd3d_make_u32(vkd3d_make_u16(buf[0], buf[1]), vkd3d_make_u16(buf[2], buf[3]));
+        *(unsigned int *)buf = t;
+        buf += 4;
+    } while (--longs);
+}
+
+/*
+ * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
+ * initialization constants.
+ */
+static void md5_init(struct md5_ctx *ctx)
+{
+    ctx->buf[0] = 0x67452301;
+    ctx->buf[1] = 0xefcdab89;
+    ctx->buf[2] = 0x98badcfe;
+    ctx->buf[3] = 0x10325476;
+
+    ctx->i[0] = ctx->i[1] = 0;
+}
+
+/*
+ * Update context to reflect the concatenation of another buffer full
+ * of bytes.
+ */
+static void md5_update(struct md5_ctx *ctx, const unsigned char *buf, unsigned int len)
+{
+    unsigned int t;
+
+    /* Update bitcount */
+    t = ctx->i[0];
+
+    if ((ctx->i[0] = t + (len << 3)) < t)
+        ctx->i[1]++;        /* Carry from low to high */
+
+    ctx->i[1] += len >> 29;
+    t = (t >> 3) & 0x3f;
+
+    /* Handle any leading odd-sized chunks */
+    if (t)
+    {
+        unsigned char *p = (unsigned char *)ctx->in + t;
+        t = DXBC_CHECKSUM_BLOCK_SIZE - t;
+
+        if (len < t)
+        {
+            memcpy(p, buf, len);
+            return;
+        }
+
+        memcpy(p, buf, t);
+        byte_reverse(ctx->in, 16);
+
+        md5_transform(ctx->buf, (unsigned int *)ctx->in);
+
+        buf += t;
+        len -= t;
+    }
+
+    /* Process data in 64-byte chunks */
+    while (len >= DXBC_CHECKSUM_BLOCK_SIZE)
+    {
+        memcpy(ctx->in, buf, DXBC_CHECKSUM_BLOCK_SIZE);
+        byte_reverse(ctx->in, 16);
+
+        md5_transform(ctx->buf, (unsigned int *)ctx->in);
+
+        buf += DXBC_CHECKSUM_BLOCK_SIZE;
+        len -= DXBC_CHECKSUM_BLOCK_SIZE;
+    }
+
+    /* Handle any remaining bytes of data. */
+    memcpy(ctx->in, buf, len);
+}
+
+static void dxbc_checksum_final(struct md5_ctx *ctx)
+{
+    unsigned int padding;
+    unsigned int length;
+    unsigned int count;
+    unsigned char *p;
+
+    /* Compute number of bytes mod 64 */
+    count = (ctx->i[0] >> 3) & 0x3F;
+
+    /* Set the first char of padding to 0x80.  This is safe since there is
+       always at least one byte free */
+    p = ctx->in + count;
+    *p++ = 0x80;
+    ++count;
+
+    /* Bytes of padding needed to make 64 bytes */
+    padding = DXBC_CHECKSUM_BLOCK_SIZE - count;
+
+    /* Pad out to 56 mod 64 */
+    if (padding < 8)
+    {
+        /* Two lots of padding:  Pad the first block to 64 bytes */
+        memset(p, 0, padding);
+        byte_reverse(ctx->in, 16);
+        md5_transform(ctx->buf, (unsigned int *)ctx->in);
+
+        /* Now fill the next block */
+        memset(ctx->in, 0, DXBC_CHECKSUM_BLOCK_SIZE);
+    }
+    else
+    {
+        /* Make place for bitcount at the beginning of the block */
+        memmove(&ctx->in[4], ctx->in, count);
+
+        /* Pad block to 60 bytes */
+        memset(p + 4, 0, padding - 4);
+    }
+
+    /* Append length in bits and transform */
+    length = ctx->i[0];
+    memcpy(&ctx->in[0], &length, sizeof(length));
+    byte_reverse(&ctx->in[4], 14);
+    length = ctx->i[0] >> 2 | 0x1;
+    memcpy(&ctx->in[DXBC_CHECKSUM_BLOCK_SIZE - 4], &length, sizeof(length));
+
+    md5_transform(ctx->buf, (unsigned int *)ctx->in);
+    byte_reverse((unsigned char *)ctx->buf, 4);
+    memcpy(ctx->digest, ctx->buf, 16);
+}
+
+#define DXBC_CHECKSUM_SKIP_BYTE_COUNT 20
+
+void vkd3d_compute_dxbc_checksum(const void *dxbc, size_t size, uint32_t checksum[4])
+{
+    const uint8_t *ptr = dxbc;
+    struct md5_ctx ctx;
+
+    assert(size > DXBC_CHECKSUM_SKIP_BYTE_COUNT);
+    ptr += DXBC_CHECKSUM_SKIP_BYTE_COUNT;
+    size -= DXBC_CHECKSUM_SKIP_BYTE_COUNT;
+
+    md5_init(&ctx);
+    md5_update(&ctx, ptr, size);
+    dxbc_checksum_final(&ctx);
+
+    memcpy(checksum, ctx.digest, sizeof(ctx.digest));
+}

libs/vkd3d/libs/vkd3d-shader/glsl.c

+/*
+ * Copyright 2021 Atharva Nimbalkar
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "vkd3d_shader_private.h"
+
+struct vkd3d_glsl_generator
+{
+    struct vkd3d_shader_version version;
+    struct vkd3d_string_buffer buffer;
+    const struct vkd3d_shader_location *location;
+    struct vkd3d_shader_message_context *message_context;
+    bool failed;
+};
+
+struct vkd3d_glsl_generator *vkd3d_glsl_generator_create(const struct vkd3d_shader_version *version,
+        struct vkd3d_shader_message_context *message_context, const struct vkd3d_shader_location *location)
+{
+    struct vkd3d_glsl_generator *generator;
+
+    if (!(generator = vkd3d_malloc(sizeof(*generator))))
+        return NULL;
+
+    memset(generator, 0, sizeof(*generator));
+    generator->version = *version;
+    vkd3d_string_buffer_init(&generator->buffer);
+    generator->location = location;
+    generator->message_context = message_context;
+    return generator;
+}
+
+static void VKD3D_PRINTF_FUNC(3, 4) vkd3d_glsl_compiler_error(
+        struct vkd3d_glsl_generator *generator,
+        enum vkd3d_shader_error error, const char *fmt, ...)
+{
+    va_list args;
+
+    va_start(args, fmt);
+    vkd3d_shader_verror(generator->message_context, generator->location, error, fmt, args);
+    va_end(args);
+    generator->failed = true;
+}
+
+static void shader_glsl_ret(struct vkd3d_glsl_generator *generator,
+        const struct vkd3d_shader_instruction *ins)
+{
+    const struct vkd3d_shader_version *version = &generator->version;
+
+    /*
+    * TODO: Implement in_subroutine
+    * TODO: shader_glsl_generate_shader_epilogue(generator);
+    */
+    if (version->major >= 4)
+    {
+        vkd3d_string_buffer_printf(&generator->buffer, "return;\n");
+    }
+}
+
+static void vkd3d_glsl_handle_instruction(struct vkd3d_glsl_generator *generator,
+        const struct vkd3d_shader_instruction *instruction)
+{
+    switch (instruction->handler_idx)
+    {
+        case VKD3DSIH_DCL_INPUT:
+        case VKD3DSIH_DCL_OUTPUT:
+        case VKD3DSIH_DCL_OUTPUT_SIV:
+            break;
+        case VKD3DSIH_RET:
+            shader_glsl_ret(generator, instruction);
+            break;
+        default:
+            vkd3d_glsl_compiler_error(generator,
+                    VKD3D_SHADER_ERROR_GLSL_INTERNAL,
+                    "Unhandled instruction %#x", instruction->handler_idx);
+            break;
+    }
+}
+
+int vkd3d_glsl_generator_generate(struct vkd3d_glsl_generator *generator,
+        struct vkd3d_shader_parser *parser, struct vkd3d_shader_code *out)
+{
+    void *code;
+    struct vkd3d_shader_instruction ins;
+
+    vkd3d_string_buffer_printf(&generator->buffer, "#version 440\n\n");
+    vkd3d_string_buffer_printf(&generator->buffer, "void main()\n{\n");
+
+    while (!vkd3d_shader_parser_is_end(parser))
+    {
+        vkd3d_shader_parser_read_instruction(parser, &ins);
+
+        if (ins.handler_idx == VKD3DSIH_INVALID)
+        {
+            vkd3d_glsl_compiler_error(generator,
+                    VKD3D_SHADER_ERROR_GLSL_INTERNAL,
+                    "Encountered unrecognized or invalid instruction.");
+            break;
+        }
+
+        vkd3d_glsl_handle_instruction(generator, &ins);
+    }
+
+    if (parser->failed || generator->failed)
+        return VKD3D_ERROR_INVALID_SHADER;
+
+    vkd3d_string_buffer_printf(&generator->buffer, "}\n");
+
+    if ((code = vkd3d_malloc(generator->buffer.buffer_size)))
+    {
+        memcpy(code, generator->buffer.buffer, generator->buffer.content_size);
+        out->size = generator->buffer.content_size;
+        out->code = code;
+    }
+    else return VKD3D_ERROR_OUT_OF_MEMORY;
+
+    return VKD3D_OK;
+}
+
+void vkd3d_glsl_generator_destroy(struct vkd3d_glsl_generator *generator)
+{
+    vkd3d_string_buffer_cleanup(&generator->buffer);
+    vkd3d_free(generator);
+}

libs/vkd3d/libs/vkd3d-shader/hlsl_constant_ops.c

+/*
+ * HLSL constant value operations for constant folding
+ *
+ * Copyright 2022 Francisco Casas for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "hlsl.h"
+
+static bool fold_cast(struct hlsl_ctx *ctx, struct hlsl_ir_constant *dst, struct hlsl_ir_constant *src)
+{
+    unsigned int k;
+    uint32_t u;
+    int32_t i;
+    double d;
+    float f;
+    bool b;
+
+    if (dst->node.data_type->dimx != src->node.data_type->dimx
+            || dst->node.data_type->dimy != src->node.data_type->dimy)
+    {
+        FIXME("Cast from %s to %s.\n", debug_hlsl_type(ctx, src->node.data_type),
+                debug_hlsl_type(ctx, dst->node.data_type));
+        return false;
+    }
+
+    for (k = 0; k < 4; ++k)
+    {
+        switch (src->node.data_type->base_type)
+        {
+            case HLSL_TYPE_FLOAT:
+            case HLSL_TYPE_HALF:
+                u = src->value[k].f;
+                i = src->value[k].f;
+                f = src->value[k].f;
+                d = src->value[k].f;
+                b = src->value[k].f;
+                break;
+
+            case HLSL_TYPE_DOUBLE:
+                u = src->value[k].d;
+                i = src->value[k].d;
+                f = src->value[k].d;
+                d = src->value[k].d;
+                b = src->value[k].d;
+                break;
+
+            case HLSL_TYPE_INT:
+                u = src->value[k].i;
+                i = src->value[k].i;
+                f = src->value[k].i;
+                d = src->value[k].i;
+                b = src->value[k].i;
+                break;
+
+            case HLSL_TYPE_UINT:
+                u = src->value[k].u;
+                i = src->value[k].u;
+                f = src->value[k].u;
+                d = src->value[k].u;
+                b = src->value[k].u;
+                break;
+
+            case HLSL_TYPE_BOOL:
+                u = src->value[k].b;
+                i = src->value[k].b;
+                f = src->value[k].b;
+                d = src->value[k].b;
+                b = src->value[k].b;
+                break;
+
+            default:
+                FIXME("Cast from %s to %s.\n", debug_hlsl_type(ctx, src->node.data_type),
+                        debug_hlsl_type(ctx, dst->node.data_type));
+                return false;
+        }
+
+        switch (dst->node.data_type->base_type)
+        {
+            case HLSL_TYPE_FLOAT:
+            case HLSL_TYPE_HALF:
+                dst->value[k].f = f;
+                break;
+
+            case HLSL_TYPE_DOUBLE:
+                dst->value[k].d = d;
+                break;
+
+            case HLSL_TYPE_INT:
+                dst->value[k].i = i;
+                break;
+
+            case HLSL_TYPE_UINT:
+                dst->value[k].u = u;
+                break;
+
+            case HLSL_TYPE_BOOL:
+                dst->value[k].b = b;
+                break;
+
+            default:
+                FIXME("Cast from %s to %s.\n", debug_hlsl_type(ctx, src->node.data_type),
+                        debug_hlsl_type(ctx, dst->node.data_type));
+                return false;
+        }
+    }
+    return true;
+}
+
+static bool fold_neg(struct hlsl_ctx *ctx, struct hlsl_ir_constant *dst, struct hlsl_ir_constant *src)
+{
+    enum hlsl_base_type type = dst->node.data_type->base_type;
+    unsigned int k;
+
+    assert(type == src->node.data_type->base_type);
+
+    for (k = 0; k < 4; ++k)
+    {
+        switch (type)
+        {
+            case HLSL_TYPE_FLOAT:
+            case HLSL_TYPE_HALF:
+                dst->value[k].f = -src->value[k].f;
+                break;
+
+            case HLSL_TYPE_DOUBLE:
+                dst->value[k].d = -src->value[k].d;
+                break;
+
+            case HLSL_TYPE_INT:
+            case HLSL_TYPE_UINT:
+                dst->value[k].u = -src->value[k].u;
+                break;
+
+            default:
+                FIXME("Fold negation for type %s.\n", debug_hlsl_type(ctx, dst->node.data_type));
+                return false;
+        }
+    }
+    return true;
+}
+
+static bool fold_add(struct hlsl_ctx *ctx, struct hlsl_ir_constant *dst, struct hlsl_ir_constant *src1,
+        struct hlsl_ir_constant *src2)
+{
+    enum hlsl_base_type type = dst->node.data_type->base_type;
+    unsigned int k;
+
+    assert(type == src1->node.data_type->base_type);
+    assert(type == src2->node.data_type->base_type);
+
+    for (k = 0; k < 4; ++k)
+    {
+        switch (type)
+        {
+            case HLSL_TYPE_FLOAT:
+            case HLSL_TYPE_HALF:
+                dst->value[k].f = src1->value[k].f + src2->value[k].f;
+                break;
+
+            case HLSL_TYPE_DOUBLE:
+                dst->value[k].d = src1->value[k].d + src2->value[k].d;
+                break;
+
+            /* Handling HLSL_TYPE_INT through the unsigned field to avoid
+             * undefined behavior with signed integers in C. */
+            case HLSL_TYPE_INT:
+            case HLSL_TYPE_UINT:
+                dst->value[k].u = src1->value[k].u + src2->value[k].u;
+                break;
+
+            default:
+                FIXME("Fold addition for type %s.\n", debug_hlsl_type(ctx, dst->node.data_type));
+                return false;
+        }
+    }
+    return true;
+}
+
+static bool fold_mul(struct hlsl_ctx *ctx, struct hlsl_ir_constant *dst,
+        struct hlsl_ir_constant *src1, struct hlsl_ir_constant *src2)
+{
+    enum hlsl_base_type type = dst->node.data_type->base_type;
+
+    assert(type == src1->node.data_type->base_type);
+    assert(type == src2->node.data_type->base_type);
+
+    for (int k = 0; k < 4; ++k)
+    {
+        switch (type)
+        {
+            case HLSL_TYPE_FLOAT:
+            case HLSL_TYPE_HALF:
+                dst->value[k].f = src1->value[k].f * src2->value[k].f;
+                break;
+
+            case HLSL_TYPE_DOUBLE:
+                dst->value[k].d = src1->value[k].d * src2->value[k].d;
+                break;
+
+            case HLSL_TYPE_INT:
+            case HLSL_TYPE_UINT:
+                dst->value[k].u = src1->value[k].u * src2->value[k].u;
+                break;
+
+            default:
+                FIXME("Fold multiplication for type %s.\n", debug_hlsl_type(ctx, dst->node.data_type));
+                return false;
+        }
+    }
+    return true;
+}
+
+bool hlsl_fold_constants(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context)
+{
+    struct hlsl_ir_constant *arg1, *arg2 = NULL, *res;
+    struct hlsl_ir_expr *expr;
+    unsigned int i;
+    bool success;
+
+    if (instr->type != HLSL_IR_EXPR)
+        return false;
+    expr = hlsl_ir_expr(instr);
+
+    for (i = 0; i < ARRAY_SIZE(expr->operands); ++i)
+    {
+        if (expr->operands[i].node && expr->operands[i].node->type != HLSL_IR_CONSTANT)
+            return false;
+    }
+    arg1 = hlsl_ir_constant(expr->operands[0].node);
+    if (expr->operands[1].node)
+        arg2 = hlsl_ir_constant(expr->operands[1].node);
+
+    if (!(res = hlsl_alloc(ctx, sizeof(*res))))
+        return false;
+    init_node(&res->node, HLSL_IR_CONSTANT, instr->data_type, instr->loc);
+
+    switch (expr->op)
+    {
+        case HLSL_OP1_CAST:
+            success = fold_cast(ctx, res, arg1);
+            break;
+
+        case HLSL_OP1_NEG:
+            success = fold_neg(ctx, res, arg1);
+            break;
+
+        case HLSL_OP2_ADD:
+            success = fold_add(ctx, res, arg1, arg2);
+            break;
+
+        case HLSL_OP2_MUL:
+            success = fold_mul(ctx, res, arg1, arg2);
+            break;
+
+        default:
+            FIXME("Fold \"%s\" expression.\n", debug_hlsl_expr_op(expr->op));
+            success = false;
+            break;
+    }
+
+    if (success)
+    {
+        list_add_before(&expr->node.entry, &res->node.entry);
+        hlsl_replace_node(&expr->node, &res->node);
+    }
+    else
+    {
+        vkd3d_free(res);
+    }
+    return success;
+}

libs/vkd3d/libs/vkd3d-shader/preproc.h

+/*
+ * HLSL preprocessor
+ *
+ * Copyright 2020 Zebediah Figura for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __VKD3D_SHADER_PREPROC_H
+#define __VKD3D_SHADER_PREPROC_H
+
+#include "vkd3d_shader_private.h"
+#include "wine/rbtree.h"
+
+struct preproc_if_state
+{
+    /* Are we currently in a "true" block? */
+    bool current_true;
+    /* Have we seen a "true" block in this #if..#endif yet? */
+    bool seen_true;
+    /* Have we seen an #else yet? */
+    bool seen_else;
+};
+
+struct preproc_buffer
+{
+    void *lexer_buffer;
+    struct vkd3d_shader_location location;
+};
+
+struct preproc_file
+{
+    struct preproc_buffer buffer;
+    struct vkd3d_shader_code code;
+    char *filename;
+
+    struct preproc_if_state *if_stack;
+    size_t if_count, if_stack_size;
+};
+
+struct preproc_text
+{
+    struct vkd3d_string_buffer text;
+    struct vkd3d_shader_location location;
+};
+
+struct preproc_expansion
+{
+    struct preproc_buffer buffer;
+    const struct preproc_text *text;
+    /* Back-pointer to the macro, if this expansion a macro body. This is
+     * necessary so that argument tokens can be correctly replaced. */
+    struct preproc_macro *macro;
+};
+
+struct preproc_macro
+{
+    struct rb_entry entry;
+    char *name;
+
+    char **arg_names;
+    size_t arg_count;
+    struct preproc_text *arg_values;
+
+    struct preproc_text body;
+};
+
+struct preproc_ctx
+{
+    const struct vkd3d_shader_preprocess_info *preprocess_info;
+    void *scanner;
+
+    struct vkd3d_shader_message_context *message_context;
+    struct vkd3d_string_buffer buffer;
+
+    struct preproc_file *file_stack;
+    size_t file_count, file_stack_size;
+
+    struct preproc_expansion *expansion_stack;
+    size_t expansion_count, expansion_stack_size;
+
+    struct rb_tree macros;
+
+    /* It's possible to parse as many as two function-like macros at once: one
+     * in the main text, and another inside of #if directives. E.g.
+     *
+     * func1(
+     * #if func2(...)
+     * #endif
+     * )
+     *
+     * It's not possible to parse more than two, however. In the case of nested
+     * calls like "func1(func2(...))", we store everything inside the outer
+     * parentheses as unparsed text, and then parse it once the argument is
+     * actually invoked.
+     */
+    struct preproc_func_state
+    {
+        struct preproc_macro *macro;
+        size_t arg_count;
+        enum
+        {
+            STATE_NONE = 0,
+            STATE_IDENTIFIER,
+            STATE_ARGS,
+        } state;
+        unsigned int paren_depth;
+    } text_func, directive_func;
+
+    int current_directive;
+
+    int lookahead_token;
+
+    bool last_was_newline;
+    bool last_was_eof;
+    bool last_was_defined;
+
+    bool error;
+};
+
+bool preproc_add_macro(struct preproc_ctx *ctx, const struct vkd3d_shader_location *loc, char *name, char **arg_names,
+        size_t arg_count, const struct vkd3d_shader_location *body_loc, struct vkd3d_string_buffer *body);
+void preproc_close_include(struct preproc_ctx *ctx, const struct vkd3d_shader_code *code);
+struct preproc_macro *preproc_find_macro(struct preproc_ctx *ctx, const char *name);
+void preproc_free_macro(struct preproc_macro *macro);
+bool preproc_push_include(struct preproc_ctx *ctx, char *filename, const struct vkd3d_shader_code *code);
+void preproc_warning(struct preproc_ctx *ctx, const struct vkd3d_shader_location *loc,
+        enum vkd3d_shader_error error, const char *format, ...) VKD3D_PRINTF_FUNC(4, 5);
+
+static inline struct preproc_file *preproc_get_top_file(struct preproc_ctx *ctx)
+{
+    assert(ctx->file_count);
+    return &ctx->file_stack[ctx->file_count - 1];
+}
+
+#endif

libs/vkd3d/libs/vkd3d/vulkan_procs.h

+/*
+ * Copyright 2016 Józef Kucia for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef VK_INSTANCE_PFN
+# define VK_INSTANCE_PFN(x)
+#endif
+
+#ifndef VK_INSTANCE_EXT_PFN
+# define VK_INSTANCE_EXT_PFN(x)
+#endif
+
+#ifndef VK_DEVICE_PFN
+# define VK_DEVICE_PFN(x)
+#endif
+
+#ifndef VK_DEVICE_EXT_PFN
+# define VK_DEVICE_EXT_PFN(x)
+#endif
+
+/* Instance functions (obtained by vkGetInstanceProcAddr). */
+VK_INSTANCE_PFN(vkDestroyInstance) /* Load vkDestroyInstance() first. */
+VK_INSTANCE_PFN(vkCreateDevice)
+VK_INSTANCE_PFN(vkEnumerateDeviceExtensionProperties)
+VK_INSTANCE_PFN(vkEnumerateDeviceLayerProperties)
+VK_INSTANCE_PFN(vkEnumeratePhysicalDevices)
+VK_INSTANCE_PFN(vkGetDeviceProcAddr)
+VK_INSTANCE_PFN(vkGetPhysicalDeviceFeatures)
+VK_INSTANCE_PFN(vkGetPhysicalDeviceFormatProperties)
+VK_INSTANCE_PFN(vkGetPhysicalDeviceImageFormatProperties)
+VK_INSTANCE_PFN(vkGetPhysicalDeviceMemoryProperties)
+VK_INSTANCE_PFN(vkGetPhysicalDeviceProperties)
+VK_INSTANCE_PFN(vkGetPhysicalDeviceQueueFamilyProperties)
+VK_INSTANCE_PFN(vkGetPhysicalDeviceSparseImageFormatProperties)
+
+/* VK_KHR_get_physical_device_properties2 */
+VK_INSTANCE_EXT_PFN(vkGetPhysicalDeviceFeatures2KHR)
+VK_INSTANCE_EXT_PFN(vkGetPhysicalDeviceProperties2KHR)
+
+/* VK_EXT_debug_report */
+VK_INSTANCE_EXT_PFN(vkCreateDebugReportCallbackEXT)
+VK_INSTANCE_EXT_PFN(vkDestroyDebugReportCallbackEXT)
+
+/* VK_EXT_calibrated_timestamps */
+VK_INSTANCE_EXT_PFN(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)
+
+/* Device functions (obtained by vkGetDeviceProcAddr). */
+VK_DEVICE_PFN(vkDestroyDevice) /* Load vkDestroyDevice() first. */
+VK_DEVICE_PFN(vkAllocateCommandBuffers)
+VK_DEVICE_PFN(vkAllocateDescriptorSets)
+VK_DEVICE_PFN(vkAllocateMemory)
+VK_DEVICE_PFN(vkBeginCommandBuffer)
+VK_DEVICE_PFN(vkBindBufferMemory)
+VK_DEVICE_PFN(vkBindImageMemory)
+VK_DEVICE_PFN(vkCmdBeginQuery)
+VK_DEVICE_PFN(vkCmdBeginRenderPass)
+VK_DEVICE_PFN(vkCmdBindDescriptorSets)
+VK_DEVICE_PFN(vkCmdBindIndexBuffer)
+VK_DEVICE_PFN(vkCmdBindPipeline)
+VK_DEVICE_PFN(vkCmdBindVertexBuffers)
+VK_DEVICE_PFN(vkCmdBlitImage)
+VK_DEVICE_PFN(vkCmdClearAttachments)
+VK_DEVICE_PFN(vkCmdClearColorImage)
+VK_DEVICE_PFN(vkCmdClearDepthStencilImage)
+VK_DEVICE_PFN(vkCmdCopyBuffer)
+VK_DEVICE_PFN(vkCmdCopyBufferToImage)
+VK_DEVICE_PFN(vkCmdCopyImage)
+VK_DEVICE_PFN(vkCmdCopyImageToBuffer)
+VK_DEVICE_PFN(vkCmdCopyQueryPoolResults)
+VK_DEVICE_PFN(vkCmdDispatch)
+VK_DEVICE_PFN(vkCmdDispatchIndirect)
+VK_DEVICE_PFN(vkCmdDraw)
+VK_DEVICE_PFN(vkCmdDrawIndexed)
+VK_DEVICE_PFN(vkCmdDrawIndexedIndirect)
+VK_DEVICE_PFN(vkCmdDrawIndirect)
+VK_DEVICE_PFN(vkCmdEndQuery)
+VK_DEVICE_PFN(vkCmdEndRenderPass)
+VK_DEVICE_PFN(vkCmdExecuteCommands)
+VK_DEVICE_PFN(vkCmdFillBuffer)
+VK_DEVICE_PFN(vkCmdNextSubpass)
+VK_DEVICE_PFN(vkCmdPipelineBarrier)
+VK_DEVICE_PFN(vkCmdPushConstants)
+VK_DEVICE_PFN(vkCmdResetEvent)
+VK_DEVICE_PFN(vkCmdResetQueryPool)
+VK_DEVICE_PFN(vkCmdResolveImage)
+VK_DEVICE_PFN(vkCmdSetBlendConstants)
+VK_DEVICE_PFN(vkCmdSetDepthBias)
+VK_DEVICE_PFN(vkCmdSetDepthBounds)
+VK_DEVICE_PFN(vkCmdSetEvent)
+VK_DEVICE_PFN(vkCmdSetLineWidth)
+VK_DEVICE_PFN(vkCmdSetScissor)
+VK_DEVICE_PFN(vkCmdSetStencilCompareMask)
+VK_DEVICE_PFN(vkCmdSetStencilReference)
+VK_DEVICE_PFN(vkCmdSetStencilWriteMask)
+VK_DEVICE_PFN(vkCmdSetViewport)
+VK_DEVICE_PFN(vkCmdUpdateBuffer)
+VK_DEVICE_PFN(vkCmdWaitEvents)
+VK_DEVICE_PFN(vkCmdWriteTimestamp)
+VK_DEVICE_PFN(vkCreateBuffer)
+VK_DEVICE_PFN(vkCreateBufferView)
+VK_DEVICE_PFN(vkCreateCommandPool)
+VK_DEVICE_PFN(vkCreateComputePipelines)
+VK_DEVICE_PFN(vkCreateDescriptorPool)
+VK_DEVICE_PFN(vkCreateDescriptorSetLayout)
+VK_DEVICE_PFN(vkCreateEvent)
+VK_DEVICE_PFN(vkCreateFence)
+VK_DEVICE_PFN(vkCreateFramebuffer)
+VK_DEVICE_PFN(vkCreateGraphicsPipelines)
+VK_DEVICE_PFN(vkCreateImage)
+VK_DEVICE_PFN(vkCreateImageView)
+VK_DEVICE_PFN(vkCreatePipelineCache)
+VK_DEVICE_PFN(vkCreatePipelineLayout)
+VK_DEVICE_PFN(vkCreateQueryPool)
+VK_DEVICE_PFN(vkCreateRenderPass)
+VK_DEVICE_PFN(vkCreateSampler)
+VK_DEVICE_PFN(vkCreateSemaphore)
+VK_DEVICE_PFN(vkCreateShaderModule)
+VK_DEVICE_PFN(vkDestroyBuffer)
+VK_DEVICE_PFN(vkDestroyBufferView)
+VK_DEVICE_PFN(vkDestroyCommandPool)
+VK_DEVICE_PFN(vkDestroyDescriptorPool)
+VK_DEVICE_PFN(vkDestroyDescriptorSetLayout)
+VK_DEVICE_PFN(vkDestroyEvent)
+VK_DEVICE_PFN(vkDestroyFence)
+VK_DEVICE_PFN(vkDestroyFramebuffer)
+VK_DEVICE_PFN(vkDestroyImage)
+VK_DEVICE_PFN(vkDestroyImageView)
+VK_DEVICE_PFN(vkDestroyPipeline)
+VK_DEVICE_PFN(vkDestroyPipelineCache)
+VK_DEVICE_PFN(vkDestroyPipelineLayout)
+VK_DEVICE_PFN(vkDestroyQueryPool)
+VK_DEVICE_PFN(vkDestroyRenderPass)
+VK_DEVICE_PFN(vkDestroySampler)
+VK_DEVICE_PFN(vkDestroySemaphore)
+VK_DEVICE_PFN(vkDestroyShaderModule)
+VK_DEVICE_PFN(vkDeviceWaitIdle)
+VK_DEVICE_PFN(vkEndCommandBuffer)
+VK_DEVICE_PFN(vkFlushMappedMemoryRanges)
+VK_DEVICE_PFN(vkFreeCommandBuffers)
+VK_DEVICE_PFN(vkFreeDescriptorSets)
+VK_DEVICE_PFN(vkFreeMemory)
+VK_DEVICE_PFN(vkGetBufferMemoryRequirements)
+VK_DEVICE_PFN(vkGetDeviceMemoryCommitment)
+VK_DEVICE_PFN(vkGetDeviceQueue)
+VK_DEVICE_PFN(vkGetEventStatus)
+VK_DEVICE_PFN(vkGetFenceStatus)
+VK_DEVICE_PFN(vkGetImageMemoryRequirements)
+VK_DEVICE_PFN(vkGetImageSparseMemoryRequirements)
+VK_DEVICE_PFN(vkGetImageSubresourceLayout)
+VK_DEVICE_PFN(vkGetPipelineCacheData)
+VK_DEVICE_PFN(vkGetQueryPoolResults)
+VK_DEVICE_PFN(vkGetRenderAreaGranularity)
+VK_DEVICE_PFN(vkInvalidateMappedMemoryRanges)
+VK_DEVICE_PFN(vkMapMemory)
+VK_DEVICE_PFN(vkMergePipelineCaches)
+VK_DEVICE_PFN(vkQueueBindSparse)
+VK_DEVICE_PFN(vkQueueSubmit)
+VK_DEVICE_PFN(vkQueueWaitIdle)
+VK_DEVICE_PFN(vkResetCommandBuffer)
+VK_DEVICE_PFN(vkResetCommandPool)
+VK_DEVICE_PFN(vkResetDescriptorPool)
+VK_DEVICE_PFN(vkResetEvent)
+VK_DEVICE_PFN(vkResetFences)
+VK_DEVICE_PFN(vkSetEvent)
+VK_DEVICE_PFN(vkUnmapMemory)
+VK_DEVICE_PFN(vkUpdateDescriptorSets)
+VK_DEVICE_PFN(vkWaitForFences)
+
+/* VK_KHR_draw_indirect_count */
+VK_DEVICE_EXT_PFN(vkCmdDrawIndirectCountKHR)
+VK_DEVICE_EXT_PFN(vkCmdDrawIndexedIndirectCountKHR)
+
+/* VK_KHR_get_memory_requirements2 */
+VK_DEVICE_EXT_PFN(vkGetBufferMemoryRequirements2KHR)
+VK_DEVICE_EXT_PFN(vkGetImageMemoryRequirements2KHR)
+VK_DEVICE_EXT_PFN(vkGetImageSparseMemoryRequirements2KHR)
+
+/* VK_KHR_maintenance3 */
+VK_DEVICE_EXT_PFN(vkGetDescriptorSetLayoutSupportKHR)
+
+/* VK_KHR_push_descriptor */
+VK_DEVICE_EXT_PFN(vkCmdPushDescriptorSetKHR)
+
+/* VK_EXT_calibrated_timestamps */
+VK_DEVICE_EXT_PFN(vkGetCalibratedTimestampsEXT)
+
+/* VK_EXT_conditional_rendering */
+VK_DEVICE_EXT_PFN(vkCmdBeginConditionalRenderingEXT)
+VK_DEVICE_EXT_PFN(vkCmdEndConditionalRenderingEXT)
+
+/* VK_EXT_debug_marker */
+VK_DEVICE_EXT_PFN(vkDebugMarkerSetObjectNameEXT)
+
+/* VK_EXT_transform_feedback */
+VK_DEVICE_EXT_PFN(vkCmdBeginQueryIndexedEXT)
+VK_DEVICE_EXT_PFN(vkCmdBeginTransformFeedbackEXT)
+VK_DEVICE_EXT_PFN(vkCmdBindTransformFeedbackBuffersEXT)
+VK_DEVICE_EXT_PFN(vkCmdEndQueryIndexedEXT)
+VK_DEVICE_EXT_PFN(vkCmdEndTransformFeedbackEXT)
+
+#undef VK_INSTANCE_PFN
+#undef VK_INSTANCE_EXT_PFN
+#undef VK_DEVICE_PFN
+#undef VK_DEVICE_EXT_PFN