nulldrv: Creation of the nulldrv, for use on Windows.
Since the sample Intel driver hasn't been ported to Windows, this nulldrv is
being used to bootstrap Windows support. It can also provide a hint to new
IHV's for how to set the magic number.
diff --git a/.gitignore b/.gitignore
index 9389c83..cc557d2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,3 +20,4 @@
layers/xgl_struct_string_helper.h
layers/xgl_struct_wrappers.cpp
layers/xgl_struct_wrappers.h
+_out64
diff --git a/CMakeLists.txt b/CMakeLists.txt
index fdfe3c9..9f84d18 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -41,10 +41,10 @@
# icd: Device dependent (DD) XGL components
# tests: XGL tests
add_subdirectory(loader)
+add_subdirectory(icd)
if (NOT WIN32)
- add_subdirectory(icd)
add_subdirectory(tests)
endif()
- add_subdirectory(layers)
- add_subdirectory(demos)
- add_subdirectory(tools/glave)
+add_subdirectory(layers)
+add_subdirectory(demos)
+add_subdirectory(tools/glave)
diff --git a/icd/CMakeLists.txt b/icd/CMakeLists.txt
index 9124ae3..74d2414 100644
--- a/icd/CMakeLists.txt
+++ b/icd/CMakeLists.txt
@@ -1,2 +1,20 @@
+function(add_compiler_flag flag)
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}" PARENT_SCOPE)
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}" PARENT_SCOPE)
+endfunction()
+
+if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+ add_compiler_flag("-DPLATFORM_LINUX=1")
+ add_compiler_flag("-DPLATFORM_POSIX=1")
+elseif (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+ add_compiler_flag("-DPLATFORM_WINDOWS=1")
+else()
+ message(FATAL_ERROR "Platform unset, build will fail--stopping at CMake time.")
+endif()
+
add_subdirectory(common)
-add_subdirectory(intel)
+if (WIN32)
+ add_subdirectory(nulldrv)
+else()
+ add_subdirectory(intel)
+endif()
diff --git a/icd/README.md b/icd/README.md
index 0edaa05..2c0b009 100644
--- a/icd/README.md
+++ b/icd/README.md
@@ -1,6 +1,7 @@
This sample driver implementation provide multiple subcomponents required to build and test an Installable Client Driver (ICD):
- [Common Infrastructure](common)
- [Implementation for Intel GPUs](intel)
+- [Null driver](nulldrv)
- [*Sample Driver Tests*](../tests)
- Now includes Golden images to verify xgl_render_tests rendering.
diff --git a/icd/common/CMakeLists.txt b/icd/common/CMakeLists.txt
index e1946cf..235601d 100644
--- a/icd/common/CMakeLists.txt
+++ b/icd/common/CMakeLists.txt
@@ -1,3 +1,7 @@
+if (WIN32)
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_CRT_SECURE_NO_WARNINGS")
+endif()
+
set(sources
icd-alloc.c
icd-format.c
diff --git a/icd/common/icd-alloc.c b/icd/common/icd-alloc.c
index 30aad78..bbe2781 100644
--- a/icd/common/icd-alloc.c
+++ b/icd/common/icd-alloc.c
@@ -42,7 +42,7 @@
{
if (alignment <= 1) {
return malloc(size);
- } else if (u_is_pow2(alignment)) {
+ } else if (u_is_pow2((uint32_t) alignment)) {
if (alignment < sizeof(void *)) {
assert(u_is_pow2(sizeof(void*)));
alignment = sizeof(void *);
@@ -50,7 +50,11 @@
size = (size + alignment - 1) & ~(alignment - 1);
+#if defined(PLATFORM_LINUX)
return aligned_alloc(alignment, size);
+#else
+ return _aligned_malloc(size, alignment);
+#endif
}
else {
return NULL;
diff --git a/icd/common/icd-format.h b/icd/common/icd-format.h
index 3ab9be8..7aa5001 100644
--- a/icd/common/icd-format.h
+++ b/icd/common/icd-format.h
@@ -31,14 +31,14 @@
#include <stdbool.h>
#include "icd.h"
-static inline bool icd_format_is_undef(XGL_FORMAT format)
+STATIC_INLINE bool icd_format_is_undef(XGL_FORMAT format)
{
return (format == XGL_FMT_UNDEFINED);
}
bool icd_format_is_ds(XGL_FORMAT format);
-static inline bool icd_format_is_color(XGL_FORMAT format)
+STATIC_INLINE bool icd_format_is_color(XGL_FORMAT format)
{
return !(icd_format_is_undef(format) || icd_format_is_ds(format));
}
@@ -53,7 +53,7 @@
bool icd_format_is_compressed(XGL_FORMAT format);
-static inline int icd_format_get_block_width(XGL_FORMAT format)
+STATIC_INLINE int icd_format_get_block_width(XGL_FORMAT format)
{
/* all compressed formats use 4x4 blocks */
return (icd_format_is_compressed(format)) ? 4 : 1;
diff --git a/icd/common/icd-utils.h b/icd/common/icd-utils.h
index 5304d15..aad6c3e 100644
--- a/icd/common/icd-utils.h
+++ b/icd/common/icd-utils.h
@@ -31,7 +31,9 @@
#include <stdbool.h>
#include <stdint.h>
#include <assert.h>
+#if defined(PLATFORM_LINUX)
#include <strings.h> /* for ffs() */
+#endif
#include "icd.h"
#if defined(NDEBUG) && defined(__GNUC__)
@@ -63,28 +65,32 @@
/**
* Return true if val is power of two, or zero.
*/
-static inline bool u_is_pow2(unsigned int val)
+STATIC_INLINE bool u_is_pow2(unsigned int val)
{
return ((val & (val - 1)) == 0);
}
-static inline int u_ffs(int val)
+STATIC_INLINE int u_ffs(int val)
{
- return ffs(val);
+#if defined(PLATFORM_LINUX)
+ return ffs(val);
+#else
+ return __lzcnt(val) + 1;
+#endif
}
-static inline unsigned int u_align(unsigned int val, unsigned alignment)
+STATIC_INLINE unsigned int u_align(unsigned int val, unsigned alignment)
{
assert(alignment && u_is_pow2(alignment));
return (val + alignment - 1) & ~(alignment - 1);
}
-static inline unsigned int u_minify(unsigned int val, unsigned level)
+STATIC_INLINE unsigned int u_minify(unsigned int val, unsigned level)
{
return (val >> level) ? val >> level : 1;
}
-static inline uint32_t u_fui(float f)
+STATIC_INLINE uint32_t u_fui(float f)
{
union {
float f;
@@ -94,7 +100,7 @@
return u.ui;
}
-static inline float u_uif(uint32_t ui)
+STATIC_INLINE float u_uif(uint32_t ui)
{
union {
float f;
@@ -104,7 +110,7 @@
return u.f;
}
-static inline int u_iround(float f)
+STATIC_INLINE int u_iround(float f)
{
if (f >= 0.0f)
return (int) (f + 0.5f);
diff --git a/icd/common/icd.h b/icd/common/icd.h
index 1e053c8..da5e007 100644
--- a/icd/common/icd.h
+++ b/icd/common/icd.h
@@ -29,9 +29,19 @@
#define ICD_H
#include <xgl.h>
+#include <xglPlatform.h>
#include <xglDbg.h>
+
+#if defined(PLATFORM_LINUX)
+
#include <xglWsiX11Ext.h>
+#else
+
+#include <xglWsiWinExt.h>
+
+#endif
+
#if defined(__GNUC__) && __GNUC__ >= 4
# define ICD_EXPORT __attribute__((visibility("default")))
#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
diff --git a/icd/nulldrv/CMakeLists.txt b/icd/nulldrv/CMakeLists.txt
new file mode 100644
index 0000000..b11840b
--- /dev/null
+++ b/icd/nulldrv/CMakeLists.txt
@@ -0,0 +1,33 @@
+# Create the nulldrv XGL DRI library
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DXGL_PROTOTYPES")
+
+add_custom_command(OUTPUT nulldrv_gpa.c
+ COMMAND ${PROJECT_SOURCE_DIR}/xgl-generate.py icd-get-proc-addr > nulldrv_gpa.c
+ DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py ${PROJECT_SOURCE_DIR}/xgl.py)
+
+set(sources
+ nulldrv.c
+ nulldrv_gpa.c
+ )
+
+set(definitions "")
+
+set(libraries
+ icd)
+
+if (WIN32)
+ list(APPEND definitions -DENABLE_WSI_WINDOWS)
+endif()
+
+add_library(XGL_nulldrv SHARED ${sources})
+target_compile_definitions(XGL_nulldrv PRIVATE ${definitions})
+target_include_directories(XGL_nulldrv PRIVATE ${include_dirs})
+target_link_libraries(XGL_nulldrv ${libraries})
+
+if (WIN32)
+ # Add in the DLL "map" file for xglGetProcAddr()
+ set_target_properties(XGL_nulldrv PROPERTIES
+ LINK_FLAGS "/DEF:${PROJECT_SOURCE_DIR}/icd/nulldrv/XGL_nulldrv.def")
+endif()
+
diff --git a/icd/nulldrv/README.md b/icd/nulldrv/README.md
new file mode 100644
index 0000000..0772b7b
--- /dev/null
+++ b/icd/nulldrv/README.md
@@ -0,0 +1,3 @@
+# Null XGL Driver
+
+This directory provides a null XGL driver
diff --git a/icd/nulldrv/XGL_nulldrv.def b/icd/nulldrv/XGL_nulldrv.def
new file mode 100644
index 0000000..bd4b499
--- /dev/null
+++ b/icd/nulldrv/XGL_nulldrv.def
@@ -0,0 +1,32 @@
+;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; XGL
+;
+; Copyright (C) 2015 LunarG, Inc.
+;
+; Permission is hereby granted, free of charge, to any person obtaining a
+; copy of this software and associated documentation files (the "Software"),
+; to deal in the Software without restriction, including without limitation
+; the rights to use, copy, modify, merge, publish, distribute, sublicense,
+; and/or sell copies of the Software, and to permit persons to whom the
+; Software is 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 Software.
+;
+; THE SOFTWARE IS 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 SOFTWARE OR THE USE OR OTHER
+; DEALINGS IN THE SOFTWARE.
+;;;; End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; The following is required on Windows, for exporting symbols from the DLL
+
+LIBRARY XGL_nulldrv
+EXPORTS
+ xglGetProcAddr
+ xglCreateInstance
+ xglEnumerateGpus
+ xglDestroyInstance
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
new file mode 100644
index 0000000..cfada53
--- /dev/null
+++ b/icd/nulldrv/nulldrv.c
@@ -0,0 +1,1873 @@
+/*
+ * XGL null driver
+ *
+ * Copyright (C) 2015 LunarG, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is 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 Software.
+ *
+ * THE SOFTWARE IS 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 SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "nulldrv.h"
+
+static const char * const nulldrv_gpu_exts[NULLDRV_EXT_COUNT] = {
+#ifdef ENABLE_WSI_X11
+ [NULLDRV_EXT_WSI_X11] = "XGL_WSI_X11",
+#endif
+#ifdef ENABLE_WSI_WINDOWS
+ [NULLDRV_EXT_WSI_WINDOWS] = "XGL_WSI_WINDOWS",
+#endif
+};
+
+static struct nulldrv_base *nulldrv_base(XGL_BASE_OBJECT base)
+{
+ return (struct nulldrv_base *) base;
+}
+
+static XGL_RESULT nulldrv_base_get_info(struct nulldrv_base *base, int type,
+ size_t *size, void *data)
+{
+ XGL_RESULT ret = XGL_SUCCESS;
+ size_t s;
+ uint32_t *count;
+
+ switch (type) {
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ {
+ XGL_MEMORY_REQUIREMENTS *mem_req = data;
+ s = sizeof(XGL_MEMORY_REQUIREMENTS);
+ *size = s;
+ if (data == NULL)
+ return ret;
+ memset(data, 0, s);
+ mem_req->memType = XGL_MEMORY_TYPE_OTHER;
+ break;
+ }
+ case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+ *size = sizeof(uint32_t);
+ if (data == NULL)
+ return ret;
+ count = (uint32_t *) data;
+ *count = 1;
+ break;
+ case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ s = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
+ *size = s;
+ if (data == NULL)
+ return ret;
+ memset(data, 0, s);
+ break;
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ s = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS);
+ *size = s;
+ if (data == NULL)
+ return ret;
+ memset(data, 0, s);
+ break;
+ default:
+ ret = XGL_ERROR_INVALID_VALUE;
+ break;
+ }
+
+ return ret;
+}
+
+static struct nulldrv_base *nulldrv_base_create(struct nulldrv_dev *dev,
+ size_t obj_size,
+ XGL_DBG_OBJECT_TYPE type)
+{
+ struct nulldrv_base *base;
+
+ if (!obj_size)
+ obj_size = sizeof(*base);
+
+ assert(obj_size >= sizeof(*base));
+
+ base = (struct nulldrv_base*)icd_alloc(obj_size, 0, XGL_SYSTEM_ALLOC_API_OBJECT);
+ if (!base)
+ return NULL;
+
+ memset(base, 0, obj_size);
+
+ // Initialize pointer to loader's dispatch table with ICD_LOADER_MAGIC
+ set_loader_magic_value(base);
+
+ if (dev == NULL) {
+ /*
+ * dev is NULL when we are creating the base device object
+ * Set dev now so that debug setup happens correctly
+ */
+ dev = (struct nulldrv_dev *) base;
+ }
+
+
+ base->get_info = NULL;
+
+ return base;
+}
+
+static XGL_RESULT nulldrv_gpu_add(int devid, const char *primary_node,
+ const char *render_node, struct nulldrv_gpu **gpu_ret)
+{
+ struct nulldrv_gpu *gpu;
+
+ gpu = icd_alloc(sizeof(*gpu), 0, XGL_SYSTEM_ALLOC_API_OBJECT);
+ if (!gpu)
+ return XGL_ERROR_OUT_OF_MEMORY;
+ memset(gpu, 0, sizeof(*gpu));
+
+ // Initialize pointer to loader's dispatch table with ICD_LOADER_MAGIC
+ set_loader_magic_value(gpu);
+
+ *gpu_ret = gpu;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_queue_create(struct nulldrv_dev *dev,
+ enum nulldrv_gpu_engine_type engine,
+ struct nulldrv_queue **queue_ret)
+{
+ struct nulldrv_queue *queue;
+
+ queue = (struct nulldrv_queue *) nulldrv_base_create(dev, sizeof(*queue),
+ XGL_DBG_OBJECT_QUEUE);
+ if (!queue)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ queue->dev = dev;
+
+ *queue_ret = queue;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT dev_create_queues(struct nulldrv_dev *dev,
+ const XGL_DEVICE_QUEUE_CREATE_INFO *queues,
+ uint32_t count)
+{
+ uint32_t i;
+
+ if (!count)
+ return XGL_ERROR_INVALID_POINTER;
+
+ for (i = 0; i < count; i++) {
+ const XGL_DEVICE_QUEUE_CREATE_INFO *q = &queues[i];
+ XGL_RESULT ret = XGL_SUCCESS;
+
+ if (q->queueCount == 1 && !dev->queues[q->queueNodeIndex]) {
+ ret = nulldrv_queue_create(dev, q->queueNodeIndex,
+ &dev->queues[q->queueNodeIndex]);
+ }
+ else {
+ ret = XGL_ERROR_INVALID_POINTER;
+ }
+
+ if (ret != XGL_SUCCESS) {
+ return ret;
+ }
+ }
+
+ return XGL_SUCCESS;
+}
+
+static enum nulldrv_ext_type nulldrv_gpu_lookup_extension(const struct nulldrv_gpu *gpu,
+ const char *ext)
+{
+ enum nulldrv_ext_type type;
+
+ for (type = 0; type < ARRAY_SIZE(nulldrv_gpu_exts); type++) {
+ if (nulldrv_gpu_exts[type] && strcmp(nulldrv_gpu_exts[type], ext) == 0)
+ break;
+ }
+
+ assert(type < NULLDRV_EXT_COUNT || type == NULLDRV_EXT_INVALID);
+
+ return type;
+}
+
+static XGL_RESULT nulldrv_desc_pool_create(struct nulldrv_dev *dev,
+ struct nulldrv_desc_pool **pool_ret)
+{
+ const uint32_t surface_count = 1;
+ const uint32_t sampler_count = 1;
+ struct nulldrv_desc_pool *pool;
+
+ pool = malloc(sizeof(*pool));
+ if (!pool)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ memset(pool, 0, sizeof(*pool));
+
+ pool->surface_desc_size = 0;
+ pool->sampler_desc_size = 0;
+
+ *pool_ret = pool;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_dev_create(struct nulldrv_gpu *gpu,
+ const XGL_DEVICE_CREATE_INFO *info,
+ struct nulldrv_dev **dev_ret)
+{
+ struct nulldrv_dev *dev;
+ uint32_t i;
+ XGL_RESULT ret;
+
+ dev = (struct nulldrv_dev *) nulldrv_base_create(NULL, sizeof(*dev),
+ XGL_DBG_OBJECT_DEVICE);
+ if (!dev)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ for (i = 0; i < info->extensionCount; i++) {
+ const enum nulldrv_ext_type ext = nulldrv_gpu_lookup_extension(gpu,
+ info->ppEnabledExtensionNames[i]);
+
+ if (ext == NULLDRV_EXT_INVALID)
+ return XGL_ERROR_INVALID_EXTENSION;
+
+ dev->exts[ext] = true;
+ }
+
+ ret = nulldrv_desc_pool_create(dev, &dev->desc_pool);
+ if (ret != XGL_SUCCESS) {
+ return ret;
+ }
+
+ ret = dev_create_queues(dev, info->pRequestedQueues,
+ info->queueRecordCount);
+ if (ret != XGL_SUCCESS) {
+ return ret;
+ }
+
+ *dev_ret = dev;
+
+ return XGL_SUCCESS;
+}
+
+static struct nulldrv_gpu *nulldrv_gpu(XGL_PHYSICAL_GPU gpu)
+{
+ return (struct nulldrv_gpu *) gpu;
+}
+
+static XGL_RESULT nulldrv_rt_view_create(struct nulldrv_dev *dev,
+ const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO *info,
+ struct nulldrv_rt_view **view_ret)
+{
+ struct nulldrv_rt_view *view;
+
+ view = (struct nulldrv_rt_view *) nulldrv_base_create(dev, sizeof(*view),
+ XGL_DBG_OBJECT_COLOR_TARGET_VIEW);
+ if (!view)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *view_ret = view;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_fence_create(struct nulldrv_dev *dev,
+ const XGL_FENCE_CREATE_INFO *info,
+ struct nulldrv_fence **fence_ret)
+{
+ struct nulldrv_fence *fence;
+
+ fence = (struct nulldrv_fence *) nulldrv_base_create(dev, sizeof(*fence),
+ XGL_DBG_OBJECT_FENCE);
+ if (!fence)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *fence_ret = fence;
+
+ return XGL_SUCCESS;
+}
+
+static struct nulldrv_dev *nulldrv_dev(XGL_DEVICE dev)
+{
+ return (struct nulldrv_dev *) dev;
+}
+
+static struct nulldrv_img *nulldrv_img_from_base(struct nulldrv_base *base)
+{
+ return (struct nulldrv_img *) base;
+}
+
+
+static XGL_RESULT img_get_info(struct nulldrv_base *base, int type,
+ size_t *size, void *data)
+{
+ struct nulldrv_img *img = nulldrv_img_from_base(base);
+ XGL_RESULT ret = XGL_SUCCESS;
+
+ switch (type) {
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ {
+ XGL_MEMORY_REQUIREMENTS *mem_req = data;
+
+ *size = sizeof(XGL_MEMORY_REQUIREMENTS);
+ if (data == NULL)
+ return ret;
+ mem_req->size = img->total_size;
+ mem_req->alignment = 4096;
+ mem_req->memType = XGL_MEMORY_TYPE_IMAGE;
+ }
+ break;
+ case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ {
+ XGL_IMAGE_MEMORY_REQUIREMENTS *img_req = data;
+
+ *size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
+ if (data == NULL)
+ return ret;
+ img_req->usage = img->usage;
+ img_req->formatClass = img->format_class;
+ img_req->samples = img->samples;
+ }
+ break;
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ {
+ XGL_BUFFER_MEMORY_REQUIREMENTS *buf_req = data;
+
+ *size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
+ if (data == NULL)
+ return ret;
+ buf_req->usage = img->usage;
+ }
+ break;
+ default:
+ ret = nulldrv_base_get_info(base, type, size, data);
+ break;
+ }
+
+ return ret;
+}
+
+static XGL_RESULT nulldrv_img_create(struct nulldrv_dev *dev,
+ const XGL_IMAGE_CREATE_INFO *info,
+ bool scanout,
+ struct nulldrv_img **img_ret)
+{
+ struct nulldrv_img *img;
+
+ img = (struct nulldrv_img *) nulldrv_base_create(dev, sizeof(*img),
+ XGL_DBG_OBJECT_IMAGE);
+ if (!img)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ img->type = info->imageType;
+ img->depth = info->extent.depth;
+ img->mip_levels = info->mipLevels;
+ img->array_size = info->arraySize;
+ img->usage = info->usage;
+ if (info->tiling == XGL_LINEAR_TILING)
+ img->format_class = XGL_IMAGE_FORMAT_CLASS_LINEAR;
+ else
+ img->format_class = icd_format_get_class(info->format);
+ img->samples = info->samples;
+
+ img->obj.base.get_info = img_get_info;
+
+ *img_ret = img;
+
+ return XGL_SUCCESS;
+}
+
+static struct nulldrv_img *nulldrv_img(XGL_IMAGE image)
+{
+ return (struct nulldrv_img *) image;
+}
+
+static XGL_RESULT nulldrv_mem_alloc(struct nulldrv_dev *dev,
+ const XGL_MEMORY_ALLOC_INFO *info,
+ struct nulldrv_mem **mem_ret)
+{
+ struct nulldrv_mem *mem;
+
+ mem = (struct nulldrv_mem *) nulldrv_base_create(dev, sizeof(*mem),
+ XGL_DBG_OBJECT_GPU_MEMORY);
+ if (!mem)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ mem->bo = _aligned_malloc(info->allocationSize, 4096);
+ if (!mem->bo) {
+ return XGL_ERROR_OUT_OF_MEMORY;
+ }
+
+ mem->size = info->allocationSize;
+
+ *mem_ret = mem;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_ds_view_create(struct nulldrv_dev *dev,
+ const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO *info,
+ struct nulldrv_ds_view **view_ret)
+{
+ struct nulldrv_img *img = nulldrv_img(info->image);
+ struct nulldrv_ds_view *view;
+
+ view = (struct nulldrv_ds_view *) nulldrv_base_create(dev, sizeof(*view),
+ XGL_DBG_OBJECT_DEPTH_STENCIL_VIEW);
+ if (!view)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ view->img = img;
+
+ view->array_size = info->arraySize;
+
+ *view_ret = view;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_sampler_create(struct nulldrv_dev *dev,
+ const XGL_SAMPLER_CREATE_INFO *info,
+ struct nulldrv_sampler **sampler_ret)
+{
+ struct nulldrv_sampler *sampler;
+
+ sampler = (struct nulldrv_sampler *) nulldrv_base_create(dev,
+ sizeof(*sampler), XGL_DBG_OBJECT_SAMPLER);
+ if (!sampler)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *sampler_ret = sampler;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_img_view_create(struct nulldrv_dev *dev,
+ const XGL_IMAGE_VIEW_CREATE_INFO *info,
+ struct nulldrv_img_view **view_ret)
+{
+ struct nulldrv_img *img = nulldrv_img(info->image);
+ struct nulldrv_img_view *view;
+ uint32_t mip_levels, array_size;
+ XGL_CHANNEL_MAPPING state_swizzles;
+
+ mip_levels = info->subresourceRange.mipLevels;
+
+ array_size = info->subresourceRange.arraySize;
+
+ view = (struct nulldrv_img_view *) nulldrv_base_create(dev, sizeof(*view),
+ XGL_DBG_OBJECT_IMAGE_VIEW);
+ if (!view)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ view->img = img;
+ view->min_lod = info->minLod;
+
+ state_swizzles = info->channels;
+
+ view->cmd_len = 8;
+
+ *view_ret = view;
+
+ return XGL_SUCCESS;
+}
+
+static void *nulldrv_mem_map(struct nulldrv_mem *mem, XGL_FLAGS flags)
+{
+ return mem->bo;
+}
+
+static struct nulldrv_mem *nulldrv_mem(XGL_GPU_MEMORY mem)
+{
+ return (struct nulldrv_mem *) mem;
+}
+
+static struct nulldrv_buf *nulldrv_buf_from_base(struct nulldrv_base *base)
+{
+ return (struct nulldrv_buf *) base;
+}
+
+static XGL_RESULT buf_get_info(struct nulldrv_base *base, int type,
+ size_t *size, void *data)
+{
+ struct nulldrv_buf *buf = nulldrv_buf_from_base(base);
+ XGL_RESULT ret = XGL_SUCCESS;
+
+ switch (type) {
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ {
+ XGL_MEMORY_REQUIREMENTS *mem_req = data;
+
+ *size = sizeof(XGL_MEMORY_REQUIREMENTS);
+ if (data == NULL)
+ return ret;
+
+ mem_req->size = buf->size;
+ mem_req->alignment = 4096;
+ mem_req->memType = XGL_MEMORY_TYPE_BUFFER;
+
+ }
+ break;
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ {
+ XGL_BUFFER_MEMORY_REQUIREMENTS *buf_req = data;
+
+ *size = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS);
+ if (data == NULL)
+ return ret;
+ buf_req->usage = buf->usage;
+ }
+ break;
+ default:
+ ret = nulldrv_base_get_info(base, type, size, data);
+ break;
+ }
+
+ return ret;
+}
+
+static XGL_RESULT nulldrv_buf_create(struct nulldrv_dev *dev,
+ const XGL_BUFFER_CREATE_INFO *info,
+ struct nulldrv_buf **buf_ret)
+{
+ struct nulldrv_buf *buf;
+
+ buf = (struct nulldrv_buf *) nulldrv_base_create(dev, sizeof(*buf),
+ XGL_DBG_OBJECT_BUFFER);
+ if (!buf)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ buf->size = info->size;
+ buf->usage = info->usage;
+
+ buf->obj.base.get_info = buf_get_info;
+
+ *buf_ret = buf;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_desc_layout_create(struct nulldrv_dev *dev,
+ XGL_FLAGS stage_flags,
+ const uint32_t *bind_points,
+ const struct nulldrv_desc_layout *prior_layout,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO *info,
+ struct nulldrv_desc_layout **layout_ret)
+{
+ struct nulldrv_desc_layout *layout;
+
+ layout = (struct nulldrv_desc_layout *)
+ nulldrv_base_create(dev, sizeof(*layout),
+ XGL_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT);
+ if (!layout)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *layout_ret = layout;
+
+ return XGL_SUCCESS;
+}
+
+static struct nulldrv_desc_layout *nulldrv_desc_layout(XGL_DESCRIPTOR_SET_LAYOUT layout)
+{
+ return (struct nulldrv_desc_layout *) layout;
+}
+
+static XGL_RESULT shader_create(struct nulldrv_dev *dev,
+ const XGL_SHADER_CREATE_INFO *info,
+ struct nulldrv_shader **sh_ret)
+{
+ const struct icd_bil_header *bil =
+ (const struct icd_bil_header *) info->pCode;
+ struct nulldrv_shader *sh;
+
+ sh = (struct nulldrv_shader *) nulldrv_base_create(dev, sizeof(*sh),
+ XGL_DBG_OBJECT_SHADER);
+ if (!sh)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *sh_ret = sh;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT graphics_pipeline_create(struct nulldrv_dev *dev,
+ const XGL_GRAPHICS_PIPELINE_CREATE_INFO *info_,
+ struct nulldrv_pipeline **pipeline_ret)
+{
+ struct nulldrv_pipeline *pipeline;
+
+ pipeline = (struct nulldrv_pipeline *)
+ nulldrv_base_create(dev, sizeof(*pipeline),
+ XGL_DBG_OBJECT_GRAPHICS_PIPELINE);
+ if (!pipeline)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *pipeline_ret = pipeline;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_viewport_state_create(struct nulldrv_dev *dev,
+ const XGL_DYNAMIC_VP_STATE_CREATE_INFO *info,
+ struct nulldrv_dynamic_vp **state_ret)
+{
+ struct nulldrv_dynamic_vp *state;
+
+ state = (struct nulldrv_dynamic_vp *) nulldrv_base_create(dev,
+ sizeof(*state), XGL_DBG_OBJECT_VIEWPORT_STATE);
+ if (!state)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *state_ret = state;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_raster_state_create(struct nulldrv_dev *dev,
+ const XGL_DYNAMIC_RS_STATE_CREATE_INFO *info,
+ struct nulldrv_dynamic_rs **state_ret)
+{
+ struct nulldrv_dynamic_rs *state;
+
+ state = (struct nulldrv_dynamic_rs *) nulldrv_base_create(dev,
+ sizeof(*state), XGL_DBG_OBJECT_RASTER_STATE);
+ if (!state)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *state_ret = state;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_blend_state_create(struct nulldrv_dev *dev,
+ const XGL_DYNAMIC_CB_STATE_CREATE_INFO *info,
+ struct nulldrv_dynamic_cb **state_ret)
+{
+ struct nulldrv_dynamic_cb *state;
+
+ state = (struct nulldrv_dynamic_cb *) nulldrv_base_create(dev,
+ sizeof(*state), XGL_DBG_OBJECT_COLOR_BLEND_STATE);
+ if (!state)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *state_ret = state;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_ds_state_create(struct nulldrv_dev *dev,
+ const XGL_DYNAMIC_DS_STATE_CREATE_INFO *info,
+ struct nulldrv_dynamic_ds **state_ret)
+{
+ struct nulldrv_dynamic_ds *state;
+
+ state = (struct nulldrv_dynamic_ds *) nulldrv_base_create(dev,
+ sizeof(*state), XGL_DBG_OBJECT_DEPTH_STENCIL_STATE);
+ if (!state)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *state_ret = state;
+
+ return XGL_SUCCESS;
+}
+
+
+static XGL_RESULT nulldrv_cmd_create(struct nulldrv_dev *dev,
+ const XGL_CMD_BUFFER_CREATE_INFO *info,
+ struct nulldrv_cmd **cmd_ret)
+{
+ int pipeline_select;
+ struct nulldrv_cmd *cmd;
+
+ pipeline_select = 0;
+
+ cmd = (struct nulldrv_cmd *) nulldrv_base_create(dev, sizeof(*cmd),
+ XGL_DBG_OBJECT_CMD_BUFFER);
+ if (!cmd)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *cmd_ret = cmd;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_desc_region_create(struct nulldrv_dev *dev,
+ XGL_DESCRIPTOR_REGION_USAGE usage,
+ uint32_t max_sets,
+ const XGL_DESCRIPTOR_REGION_CREATE_INFO *info,
+ struct nulldrv_desc_region **region_ret)
+{
+ struct nulldrv_desc_region *region;
+
+ region = (struct nulldrv_desc_region *)
+ nulldrv_base_create(dev, sizeof(*region),
+ XGL_DBG_OBJECT_DESCRIPTOR_REGION);
+ if (!region)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ region->dev = dev;
+
+ *region_ret = region;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_desc_set_create(struct nulldrv_dev *dev,
+ struct nulldrv_desc_region *region,
+ XGL_DESCRIPTOR_SET_USAGE usage,
+ const struct nulldrv_desc_layout *layout,
+ struct nulldrv_desc_set **set_ret)
+{
+ struct nulldrv_desc_set *set;
+
+ set = (struct nulldrv_desc_set *)
+ nulldrv_base_create(dev, sizeof(*set),
+ XGL_DBG_OBJECT_DESCRIPTOR_SET);
+ if (!set)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ set->pool = dev->desc_pool;
+ set->layout = layout;
+ *set_ret = set;
+
+ return XGL_SUCCESS;
+}
+
+static struct nulldrv_desc_region *nulldrv_desc_region(XGL_DESCRIPTOR_REGION region)
+{
+ return (struct nulldrv_desc_region *) region;
+}
+
+static XGL_RESULT nulldrv_fb_create(struct nulldrv_dev *dev,
+ const XGL_FRAMEBUFFER_CREATE_INFO* info,
+ struct nulldrv_framebuffer ** fb_ret)
+{
+
+ struct nulldrv_framebuffer *fb;
+ fb = (struct nulldrv_framebuffer *) nulldrv_base_create(dev, sizeof(*fb),
+ XGL_DBG_OBJECT_FRAMEBUFFER);
+ if (!fb)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *fb_ret = fb;
+
+ return XGL_SUCCESS;
+
+}
+
+static XGL_RESULT nulldrv_render_pass_create(struct nulldrv_dev *dev,
+ const XGL_RENDER_PASS_CREATE_INFO* info,
+ struct nulldrv_render_pass** rp_ret)
+{
+ struct nulldrv_render_pass *rp;
+ rp = (struct nulldrv_render_pass *) nulldrv_base_create(dev, sizeof(*rp),
+ XGL_DBG_OBJECT_RENDER_PASS);
+ if (!rp)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *rp_ret = rp;
+
+ return XGL_SUCCESS;
+}
+
+
+//*********************************************
+// Driver entry points
+//*********************************************
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateBuffer(
+ XGL_DEVICE device,
+ const XGL_BUFFER_CREATE_INFO* pCreateInfo,
+ XGL_BUFFER* pBuffer)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_buf_create(dev, pCreateInfo, (struct nulldrv_buf **) pBuffer);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateCommandBuffer(
+ XGL_DEVICE device,
+ const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
+ XGL_CMD_BUFFER* pCmdBuffer)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_cmd_create(dev, pCreateInfo,
+ (struct nulldrv_cmd **) pCmdBuffer);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglBeginCommandBuffer(
+ XGL_CMD_BUFFER cmdBuffer,
+ const XGL_CMD_BUFFER_BEGIN_INFO *info)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglEndCommandBuffer(
+ XGL_CMD_BUFFER cmdBuffer)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglResetCommandBuffer(
+ XGL_CMD_BUFFER cmdBuffer)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT void XGLAPI xglCmdInitAtomicCounters(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ uint32_t startCounter,
+ uint32_t counterCount,
+ const uint32_t* pData)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdLoadAtomicCounters(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ uint32_t startCounter,
+ uint32_t counterCount,
+ XGL_BUFFER srcBuffer,
+ XGL_GPU_SIZE srcOffset)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdSaveAtomicCounters(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ uint32_t startCounter,
+ uint32_t counterCount,
+ XGL_BUFFER destBuffer,
+ XGL_GPU_SIZE destOffset)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdDbgMarkerBegin(
+ XGL_CMD_BUFFER cmdBuffer,
+ const char* pMarker)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdDbgMarkerEnd(
+ XGL_CMD_BUFFER cmdBuffer)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdCopyBuffer(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER srcBuffer,
+ XGL_BUFFER destBuffer,
+ uint32_t regionCount,
+ const XGL_BUFFER_COPY* pRegions)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdCopyImage(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE destImage,
+ uint32_t regionCount,
+ const XGL_IMAGE_COPY* pRegions)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdCopyBufferToImage(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER srcBuffer,
+ XGL_IMAGE destImage,
+ uint32_t regionCount,
+ const XGL_BUFFER_IMAGE_COPY* pRegions)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdCopyImageToBuffer(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_BUFFER destBuffer,
+ uint32_t regionCount,
+ const XGL_BUFFER_IMAGE_COPY* pRegions)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdCloneImageData(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE_LAYOUT srcImageLayout,
+ XGL_IMAGE destImage,
+ XGL_IMAGE_LAYOUT destImageLayout)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdUpdateBuffer(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER destBuffer,
+ XGL_GPU_SIZE destOffset,
+ XGL_GPU_SIZE dataSize,
+ const uint32_t* pData)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdFillBuffer(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER destBuffer,
+ XGL_GPU_SIZE destOffset,
+ XGL_GPU_SIZE fillSize,
+ uint32_t data)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdClearColorImage(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ const float color[4],
+ uint32_t rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdClearColorImageRaw(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ const uint32_t color[4],
+ uint32_t rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdClearDepthStencil(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ float depth,
+ uint32_t stencil,
+ uint32_t rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdResolveImage(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE destImage,
+ uint32_t rectCount,
+ const XGL_IMAGE_RESOLVE* pRects)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdBeginQuery(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ uint32_t slot,
+ XGL_FLAGS flags)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdEndQuery(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ uint32_t slot)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdResetQueryPool(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ uint32_t startQuery,
+ uint32_t queryCount)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdSetEvent(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_EVENT event_,
+ XGL_SET_EVENT pipeEvent)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdResetEvent(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_EVENT event_)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdWriteTimestamp(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_TIMESTAMP_TYPE timestampType,
+ XGL_BUFFER destBuffer,
+ XGL_GPU_SIZE destOffset)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdBindPipeline(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_PIPELINE pipeline)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdBindPipelineDelta(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_PIPELINE_DELTA delta)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdBindDynamicStateObject(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_STATE_BIND_POINT stateBindPoint,
+ XGL_DYNAMIC_STATE_OBJECT state)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdBindDescriptorSet(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_DESCRIPTOR_SET descriptorSet,
+ const uint32_t* pUserData)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdBindVertexBuffer(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER buffer,
+ XGL_GPU_SIZE offset,
+ uint32_t binding)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdBindIndexBuffer(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER buffer,
+ XGL_GPU_SIZE offset,
+ XGL_INDEX_TYPE indexType)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdDraw(
+ XGL_CMD_BUFFER cmdBuffer,
+ uint32_t firstVertex,
+ uint32_t vertexCount,
+ uint32_t firstInstance,
+ uint32_t instanceCount)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdDrawIndexed(
+ XGL_CMD_BUFFER cmdBuffer,
+ uint32_t firstIndex,
+ uint32_t indexCount,
+ int32_t vertexOffset,
+ uint32_t firstInstance,
+ uint32_t instanceCount)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdDrawIndirect(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER buffer,
+ XGL_GPU_SIZE offset,
+ uint32_t count,
+ uint32_t stride)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdDrawIndexedIndirect(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER buffer,
+ XGL_GPU_SIZE offset,
+ uint32_t count,
+ uint32_t stride)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdDispatch(
+ XGL_CMD_BUFFER cmdBuffer,
+ uint32_t x,
+ uint32_t y,
+ uint32_t z)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdDispatchIndirect(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER buffer,
+ XGL_GPU_SIZE offset)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdWaitEvents(
+ XGL_CMD_BUFFER cmdBuffer,
+ const XGL_EVENT_WAIT_INFO* pWaitInfo)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdPipelineBarrier(
+ XGL_CMD_BUFFER cmdBuffer,
+ const XGL_PIPELINE_BARRIER* pBarrier)
+{
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateDevice(
+ XGL_PHYSICAL_GPU gpu_,
+ const XGL_DEVICE_CREATE_INFO* pCreateInfo,
+ XGL_DEVICE* pDevice)
+{
+ struct nulldrv_gpu *gpu = nulldrv_gpu(gpu_);
+ return nulldrv_dev_create(gpu, pCreateInfo, (struct nulldrv_dev**)pDevice);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDestroyDevice(
+ XGL_DEVICE device)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetDeviceQueue(
+ XGL_DEVICE device,
+ XGL_QUEUE_TYPE queueType,
+ uint32_t queueIndex,
+ XGL_QUEUE* pQueue)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+ *pQueue = dev->queues[0];
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDeviceWaitIdle(
+ XGL_DEVICE device)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetValidationLevel(
+ XGL_DEVICE device,
+ XGL_VALIDATION_LEVEL validationLevel)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetMessageFilter(
+ XGL_DEVICE device,
+ int32_t msgCode,
+ XGL_DBG_MSG_FILTER filter)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetDeviceOption(
+ XGL_DEVICE device,
+ XGL_DBG_DEVICE_OPTION dbgOption,
+ size_t dataSize,
+ const void* pData)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateEvent(
+ XGL_DEVICE device,
+ const XGL_EVENT_CREATE_INFO* pCreateInfo,
+ XGL_EVENT* pEvent)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetEventStatus(
+ XGL_EVENT event_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglSetEvent(
+ XGL_EVENT event_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglResetEvent(
+ XGL_EVENT event_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateFence(
+ XGL_DEVICE device,
+ const XGL_FENCE_CREATE_INFO* pCreateInfo,
+ XGL_FENCE* pFence)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_fence_create(dev, pCreateInfo,
+ (struct nulldrv_fence **) pFence);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetFenceStatus(
+ XGL_FENCE fence_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglWaitForFences(
+ XGL_DEVICE device,
+ uint32_t fenceCount,
+ const XGL_FENCE* pFences,
+ bool32_t waitAll,
+ uint64_t timeout)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetFormatInfo(
+ XGL_DEVICE device,
+ XGL_FORMAT format,
+ XGL_FORMAT_INFO_TYPE infoType,
+ size_t* pDataSize,
+ void* pData)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetGpuInfo(
+ XGL_PHYSICAL_GPU gpu_,
+ XGL_PHYSICAL_GPU_INFO_TYPE infoType,
+ size_t* pDataSize,
+ void* pData)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(
+ XGL_PHYSICAL_GPU gpu_,
+ const char* pExtName)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(
+ XGL_PHYSICAL_GPU gpu0_,
+ XGL_PHYSICAL_GPU gpu1_,
+ XGL_GPU_COMPATIBILITY_INFO* pInfo)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglOpenPeerImage(
+ XGL_DEVICE device,
+ const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo,
+ XGL_IMAGE* pImage,
+ XGL_GPU_MEMORY* pMem)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateImage(
+ XGL_DEVICE device,
+ const XGL_IMAGE_CREATE_INFO* pCreateInfo,
+ XGL_IMAGE* pImage)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_img_create(dev, pCreateInfo, false,
+ (struct nulldrv_img **) pImage);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetImageSubresourceInfo(
+ XGL_IMAGE image,
+ const XGL_IMAGE_SUBRESOURCE* pSubresource,
+ XGL_SUBRESOURCE_INFO_TYPE infoType,
+ size_t* pDataSize,
+ void* pData)
+{
+ const struct nulldrv_img *img = nulldrv_img(image);
+ XGL_RESULT ret = XGL_SUCCESS;
+
+ switch (infoType) {
+ case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+ {
+ XGL_SUBRESOURCE_LAYOUT *layout = (XGL_SUBRESOURCE_LAYOUT *) pData;
+
+ *pDataSize = sizeof(XGL_SUBRESOURCE_LAYOUT);
+
+ if (pData == NULL)
+ return ret;
+ layout->offset = 0;
+ layout->size = 1;
+ layout->rowPitch = 4;
+ layout->depthPitch = 4;
+ }
+ break;
+ default:
+ ret = XGL_ERROR_INVALID_VALUE;
+ break;
+ }
+
+ return ret;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglSetFastClearColor(
+ XGL_IMAGE image,
+ const float color[4])
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglSetFastClearDepth(
+ XGL_IMAGE image,
+ float depth)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglAllocMemory(
+ XGL_DEVICE device,
+ const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
+ XGL_GPU_MEMORY* pMem)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_mem_alloc(dev, pAllocInfo, (struct nulldrv_mem **) pMem);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglFreeMemory(
+ XGL_GPU_MEMORY mem_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglSetMemoryPriority(
+ XGL_GPU_MEMORY mem_,
+ XGL_MEMORY_PRIORITY priority)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglMapMemory(
+ XGL_GPU_MEMORY mem_,
+ XGL_FLAGS flags,
+ void** ppData)
+{
+ struct nulldrv_mem *mem = nulldrv_mem(mem_);
+ void *ptr = nulldrv_mem_map(mem, flags);
+
+ *ppData = ptr;
+
+ return (ptr) ? XGL_SUCCESS : XGL_ERROR_UNKNOWN;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglUnmapMemory(
+ XGL_GPU_MEMORY mem_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglPinSystemMemory(
+ XGL_DEVICE device,
+ const void* pSysMem,
+ size_t memSize,
+ XGL_GPU_MEMORY* pMem)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglOpenSharedMemory(
+ XGL_DEVICE device,
+ const XGL_MEMORY_OPEN_INFO* pOpenInfo,
+ XGL_GPU_MEMORY* pMem)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglOpenPeerMemory(
+ XGL_DEVICE device,
+ const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo,
+ XGL_GPU_MEMORY* pMem)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateInstance(
+ const XGL_APPLICATION_INFO* pAppInfo,
+ const XGL_ALLOC_CALLBACKS* pAllocCb,
+ XGL_INSTANCE* pInstance)
+{
+ struct nulldrv_instance *inst;
+
+ inst = (struct nulldrv_instance *) nulldrv_base_create(NULL, sizeof(*inst),
+ XGL_DBG_OBJECT_INSTANCE);
+ if (!inst)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ inst->obj.base.get_info = NULL;
+
+ *pInstance = (XGL_INSTANCE*)inst;
+
+ return icd_allocator_init(pAllocCb);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDestroyInstance(
+ XGL_INSTANCE pInstance)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglEnumerateGpus(
+ XGL_INSTANCE instance,
+ uint32_t maxGpus,
+ uint32_t* pGpuCount,
+ XGL_PHYSICAL_GPU* pGpus)
+{
+ XGL_RESULT ret;
+ struct nulldrv_gpu *gpu;
+ *pGpuCount = 1;
+ ret = nulldrv_gpu_add(0, 0, 0, &gpu);
+ if (ret == XGL_SUCCESS)
+ pGpus[0] = (XGL_PHYSICAL_GPU) gpu;
+ return ret;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(
+ XGL_PHYSICAL_GPU gpu,
+ size_t maxLayerCount,
+ size_t maxStringSize,
+ size_t* pOutLayerCount,
+ char* const* pOutLayers,
+ void* pReserved)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(
+ XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback,
+ void* pUserData)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(
+ XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption(
+ XGL_DBG_GLOBAL_OPTION dbgOption,
+ size_t dataSize,
+ const void* pData)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDestroyObject(
+ XGL_OBJECT object)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetObjectInfo(
+ XGL_BASE_OBJECT object,
+ XGL_OBJECT_INFO_TYPE infoType,
+ size_t* pDataSize,
+ void* pData)
+{
+ struct nulldrv_base *base = nulldrv_base(object);
+
+ return base->get_info(base, infoType, pDataSize, pData);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglBindObjectMemory(
+ XGL_OBJECT object,
+ uint32_t allocationIdx,
+ XGL_GPU_MEMORY mem_,
+ XGL_GPU_SIZE memOffset)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglBindObjectMemoryRange(
+ XGL_OBJECT object,
+ uint32_t allocationIdx,
+ XGL_GPU_SIZE rangeOffset,
+ XGL_GPU_SIZE rangeSize,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE memOffset)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglBindImageMemoryRange(
+ XGL_IMAGE image,
+ uint32_t allocationIdx,
+ const XGL_IMAGE_MEMORY_BIND_INFO* bindInfo,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE memOffset)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetObjectTag(
+ XGL_BASE_OBJECT object,
+ size_t tagSize,
+ const void* pTag)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(
+ XGL_DEVICE device,
+ const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+ XGL_PIPELINE* pPipeline)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return graphics_pipeline_create(dev, pCreateInfo,
+ (struct nulldrv_pipeline **) pPipeline);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(
+ XGL_DEVICE device,
+ const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
+ XGL_PIPELINE* pPipeline)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglStorePipeline(
+ XGL_PIPELINE pipeline,
+ size_t* pDataSize,
+ void* pData)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglLoadPipeline(
+ XGL_DEVICE device,
+ size_t dataSize,
+ const void* pData,
+ XGL_PIPELINE* pPipeline)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreatePipelineDelta(
+ XGL_DEVICE device,
+ XGL_PIPELINE p1,
+ XGL_PIPELINE p2,
+ XGL_PIPELINE_DELTA* delta)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateQueryPool(
+ XGL_DEVICE device,
+ const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo,
+ XGL_QUERY_POOL* pQueryPool)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetQueryPoolResults(
+ XGL_QUERY_POOL queryPool,
+ uint32_t startQuery,
+ uint32_t queryCount,
+ size_t* pDataSize,
+ void* pData)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglQueueSetGlobalMemReferences(
+ XGL_QUEUE queue,
+ uint32_t memRefCount,
+ const XGL_MEMORY_REF* pMemRefs)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglQueueWaitIdle(
+ XGL_QUEUE queue_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(
+ XGL_QUEUE queue_,
+ uint32_t cmdBufferCount,
+ const XGL_CMD_BUFFER* pCmdBuffers,
+ uint32_t memRefCount,
+ const XGL_MEMORY_REF* pMemRefs,
+ XGL_FENCE fence_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglOpenSharedQueueSemaphore(
+ XGL_DEVICE device,
+ const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo,
+ XGL_QUEUE_SEMAPHORE* pSemaphore)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateQueueSemaphore(
+ XGL_DEVICE device,
+ const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo,
+ XGL_QUEUE_SEMAPHORE* pSemaphore)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglSignalQueueSemaphore(
+ XGL_QUEUE queue,
+ XGL_QUEUE_SEMAPHORE semaphore)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglWaitQueueSemaphore(
+ XGL_QUEUE queue,
+ XGL_QUEUE_SEMAPHORE semaphore)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateSampler(
+ XGL_DEVICE device,
+ const XGL_SAMPLER_CREATE_INFO* pCreateInfo,
+ XGL_SAMPLER* pSampler)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_sampler_create(dev, pCreateInfo,
+ (struct nulldrv_sampler **) pSampler);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateShader(
+ XGL_DEVICE device,
+ const XGL_SHADER_CREATE_INFO* pCreateInfo,
+ XGL_SHADER* pShader)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return shader_create(dev, pCreateInfo, (struct nulldrv_shader **) pShader);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicViewportState(
+ XGL_DEVICE device,
+ const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DYNAMIC_VP_STATE_OBJECT* pState)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_viewport_state_create(dev, pCreateInfo,
+ (struct nulldrv_dynamic_vp **) pState);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicRasterState(
+ XGL_DEVICE device,
+ const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DYNAMIC_RS_STATE_OBJECT* pState)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_raster_state_create(dev, pCreateInfo,
+ (struct nulldrv_dynamic_rs **) pState);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicColorBlendState(
+ XGL_DEVICE device,
+ const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DYNAMIC_CB_STATE_OBJECT* pState)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_blend_state_create(dev, pCreateInfo,
+ (struct nulldrv_dynamic_cb **) pState);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState(
+ XGL_DEVICE device,
+ const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DYNAMIC_DS_STATE_OBJECT* pState)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_ds_state_create(dev, pCreateInfo,
+ (struct nulldrv_dynamic_ds **) pState);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateBufferView(
+ XGL_DEVICE device,
+ const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_BUFFER_VIEW* pView)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateImageView(
+ XGL_DEVICE device,
+ const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_IMAGE_VIEW* pView)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_img_view_create(dev, pCreateInfo,
+ (struct nulldrv_img_view **) pView);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateColorAttachmentView(
+ XGL_DEVICE device,
+ const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_COLOR_ATTACHMENT_VIEW* pView)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_rt_view_create(dev, pCreateInfo,
+ (struct nulldrv_rt_view **) pView);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateDepthStencilView(
+ XGL_DEVICE device,
+ const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_DEPTH_STENCIL_VIEW* pView)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_ds_view_create(dev, pCreateInfo,
+ (struct nulldrv_ds_view **) pView);
+
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSetLayout(
+ XGL_DEVICE device,
+ XGL_FLAGS stageFlags,
+ const uint32_t* pSetBindPoints,
+ XGL_DESCRIPTOR_SET_LAYOUT priorSetLayout,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pSetLayoutInfoList,
+ XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+ struct nulldrv_desc_layout *prior_layout = nulldrv_desc_layout(priorSetLayout);
+
+ return nulldrv_desc_layout_create(dev, stageFlags, pSetBindPoints,
+ prior_layout, pSetLayoutInfoList,
+ (struct nulldrv_desc_layout **) pSetLayout);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglBeginDescriptorRegionUpdate(
+ XGL_DEVICE device,
+ XGL_DESCRIPTOR_UPDATE_MODE updateMode)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglEndDescriptorRegionUpdate(
+ XGL_DEVICE device,
+ XGL_CMD_BUFFER cmd_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorRegion(
+ XGL_DEVICE device,
+ XGL_DESCRIPTOR_REGION_USAGE regionUsage,
+ uint32_t maxSets,
+ const XGL_DESCRIPTOR_REGION_CREATE_INFO* pCreateInfo,
+ XGL_DESCRIPTOR_REGION* pDescriptorRegion)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_desc_region_create(dev, regionUsage, maxSets, pCreateInfo,
+ (struct nulldrv_desc_region **) pDescriptorRegion);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglClearDescriptorRegion(
+ XGL_DESCRIPTOR_REGION descriptorRegion)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglAllocDescriptorSets(
+ XGL_DESCRIPTOR_REGION descriptorRegion,
+ XGL_DESCRIPTOR_SET_USAGE setUsage,
+ uint32_t count,
+ const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts,
+ XGL_DESCRIPTOR_SET* pDescriptorSets,
+ uint32_t* pCount)
+{
+ struct nulldrv_desc_region *region = nulldrv_desc_region(descriptorRegion);
+ struct nulldrv_dev *dev = region->dev;
+ XGL_RESULT ret = XGL_SUCCESS;
+ uint32_t i;
+
+ for (i = 0; i < count; i++) {
+ const struct nulldrv_desc_layout *layout =
+ nulldrv_desc_layout((XGL_DESCRIPTOR_SET_LAYOUT) pSetLayouts[i]);
+
+ ret = nulldrv_desc_set_create(dev, region, setUsage, layout,
+ (struct nulldrv_desc_set **) &pDescriptorSets[i]);
+ if (ret != XGL_SUCCESS)
+ break;
+ }
+
+ if (pCount)
+ *pCount = i;
+
+ return ret;
+}
+
+ICD_EXPORT void XGLAPI xglClearDescriptorSets(
+ XGL_DESCRIPTOR_REGION descriptorRegion,
+ uint32_t count,
+ const XGL_DESCRIPTOR_SET* pDescriptorSets)
+{
+}
+
+ICD_EXPORT void XGLAPI xglUpdateDescriptors(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ const void* pUpdateChain)
+{
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateFramebuffer(
+ XGL_DEVICE device,
+ const XGL_FRAMEBUFFER_CREATE_INFO* info,
+ XGL_FRAMEBUFFER* fb_ret)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_fb_create(dev, info, (struct nulldrv_framebuffer **) fb_ret);
+}
+
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateRenderPass(
+ XGL_DEVICE device,
+ const XGL_RENDER_PASS_CREATE_INFO* info,
+ XGL_RENDER_PASS* rp_ret)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_render_pass_create(dev, info, (struct nulldrv_render_pass **) rp_ret);
+}
+
+ICD_EXPORT void XGLAPI xglCmdBeginRenderPass(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_RENDER_PASS renderPass)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdEndRenderPass(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_RENDER_PASS renderPass)
+{
+}
diff --git a/icd/nulldrv/nulldrv.h b/icd/nulldrv/nulldrv.h
new file mode 100644
index 0000000..20fdd72
--- /dev/null
+++ b/icd/nulldrv/nulldrv.h
@@ -0,0 +1,213 @@
+/*
+ * XGL
+ *
+ * Copyright (C) 2014 LunarG, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is 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 Software.
+ *
+ * THE SOFTWARE IS 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 SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef NULLDRV_H
+#define NULLDRV_H
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+
+#include <xgl.h>
+#include <xglDbg.h>
+#include <xglIcd.h>
+
+#if defined(PLATFORM_LINUX)
+#include <xglWsiX11Ext.h>
+#else
+#include <xglWsiWinExt.h>
+#endif
+
+#ifndef STATIC_INLINE
+#if defined(PLATFORM_LINUX)
+#define STATIC_INLINE static inline
+#else
+#define STATIC_INLINE static
+#endif
+#endif
+
+#include "icd.h"
+#include "icd-alloc.h"
+
+#include "icd-format.h"
+#include "icd-utils.h"
+
+struct nulldrv_base {
+ void *loader_data;
+ uint32_t magic;
+ XGL_RESULT (*get_info)(struct nulldrv_base *base, int type1,
+ size_t *size, void *data);
+};
+
+struct nulldrv_obj {
+ struct nulldrv_base base;
+};
+
+struct nulldrv_base *nulldrv_base_create(struct nulldrv_dev *dev,
+ size_t obj_size,
+ XGL_DBG_OBJECT_TYPE type1);
+
+enum nulldrv_ext_type {
+ NULLDRV_EXT_WSI_X11,
+ NULLDRV_EXT_WSI_WINDOWS,
+ NULLDRV_EXT_COUNT,
+ NULLDRV_EXT_INVALID = NULLDRV_EXT_COUNT,
+};
+
+
+struct nulldrv_instance {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_gpu {
+ void *loader_data;
+};
+
+struct nulldrv_dev {
+ struct nulldrv_base base;
+ bool exts[NULLDRV_EXT_COUNT];
+ struct nulldrv_desc_pool *desc_pool;
+ struct nulldrv_queue *queues[1];
+};
+
+struct nulldrv_layout {
+ enum nulldrv_layout_aux_type aux;
+};
+
+struct nulldrv_desc_pool {
+ uint32_t surface_desc_size;
+ uint32_t sampler_desc_size;
+};
+
+
+struct nulldrv_queue {
+ struct nulldrv_base base;
+ struct nulldrv_dev *dev;
+};
+
+struct nulldrv_rt_view {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_fence {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_img {
+ struct nulldrv_obj obj;
+ XGL_IMAGE_TYPE type;
+ int32_t depth;
+ uint32_t mip_levels;
+ uint32_t array_size;
+ XGL_FLAGS usage;
+ XGL_IMAGE_FORMAT_CLASS format_class;
+ uint32_t samples;
+ size_t total_size;
+};
+
+struct nulldrv_mem {
+ struct nulldrv_base base;
+ struct nulldrv_bo *bo;
+ XGL_GPU_SIZE size;
+};
+
+struct nulldrv_ds_view {
+ struct nulldrv_obj obj;
+ struct nulldrv_img *img;
+ uint32_t array_size;
+};
+
+struct nulldrv_sampler {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_img_view {
+ struct nulldrv_obj obj;
+ struct nulldrv_img *img;
+ float min_lod;
+ uint32_t cmd_len;
+};
+
+struct nulldrv_buf {
+ struct nulldrv_obj obj;
+ XGL_GPU_SIZE size;
+ XGL_FLAGS usage;
+};
+
+struct nulldrv_desc_layout {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_shader {
+ struct nulldrv_obj obj;
+
+};
+
+
+struct nulldrv_pipeline {
+ struct nulldrv_obj obj;
+ struct nulldrv_dev *dev;
+};
+
+struct nulldrv_dynamic_vp {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_dynamic_rs {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_dynamic_cb {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_dynamic_ds {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_cmd {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_desc_region {
+ struct nulldrv_obj obj;
+ struct nulldrv_dev *dev;
+};
+
+struct nulldrv_desc_set {
+ struct nulldrv_obj obj;
+ struct nulldrv_desc_pool *pool;
+ const struct nulldrv_desc_layout *layout;
+};
+
+struct nulldrv_framebuffer {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_render_pass {
+ struct nulldrv_obj obj;
+};
+
+#endif /* NULLDRV_H */
diff --git a/include/xglWsiWinExt.h b/include/xglWsiWinExt.h
new file mode 100644
index 0000000..73b52fb
--- /dev/null
+++ b/include/xglWsiWinExt.h
@@ -0,0 +1,9 @@
+/* IN DEVELOPMENT. DO NOT SHIP. */
+
+#ifndef __XGLWSIWINEXT_H__
+#define __XGLWSIWINEXT_H__
+
+
+// TODO: create the contents of this file
+
+#endif // __XGLWSIWINEXT_H__