Stage 1 of rename
TODO: re-enable glave build, advance API for glave
v2: get rid of outdated code in tri introduced by rebase
rename wsi_null.c (olv)
diff --git a/layers/CMakeLists.txt b/layers/CMakeLists.txt
index 3a9c3e8..7e3bf59 100644
--- a/layers/CMakeLists.txt
+++ b/layers/CMakeLists.txt
@@ -1,37 +1,37 @@
cmake_minimum_required (VERSION 2.8.11)
-macro(run_xgl_helper subcmd)
+macro(run_vk_helper subcmd)
add_custom_command(OUTPUT ${ARGN}
- COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl_helper.py --${subcmd} ${PROJECT_SOURCE_DIR}/include/xgl.h --abs_out_dir ${CMAKE_CURRENT_BINARY_DIR}
- DEPENDS ${PROJECT_SOURCE_DIR}/xgl_helper.py ${PROJECT_SOURCE_DIR}/include/xgl.h
+ COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/vk_helper.py --${subcmd} ${PROJECT_SOURCE_DIR}/include/vulkan.h --abs_out_dir ${CMAKE_CURRENT_BINARY_DIR}
+ DEPENDS ${PROJECT_SOURCE_DIR}/vk_helper.py ${PROJECT_SOURCE_DIR}/include/vulkan.h
)
endmacro()
-macro(run_xgl_layer_generate subcmd output)
+macro(run_vk_layer_generate subcmd output)
add_custom_command(OUTPUT ${output}
- COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-layer-generate.py ${subcmd} ${PROJECT_SOURCE_DIR}/include/xgl.h > ${output}
- DEPENDS ${PROJECT_SOURCE_DIR}/xgl-layer-generate.py ${PROJECT_SOURCE_DIR}/include/xgl.h ${PROJECT_SOURCE_DIR}/xgl.py
+ COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-layer-generate.py ${subcmd} ${PROJECT_SOURCE_DIR}/include/vulkan.h > ${output}
+ DEPENDS ${PROJECT_SOURCE_DIR}/xgl-layer-generate.py ${PROJECT_SOURCE_DIR}/include/vulkan.h ${PROJECT_SOURCE_DIR}/xgl.py
)
endmacro()
if (WIN32)
- macro(add_xgl_layer target)
- add_custom_command(OUTPUT XGLLayer${target}.def
- COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py win-def-file XGLLayer${target} layer > XGLLayer${target}.def
+ macro(add_vk_layer target)
+ add_custom_command(OUTPUT VKLayer${target}.def
+ COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py win-def-file VKLayer${target} layer > VKLayer${target}.def
DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py ${PROJECT_SOURCE_DIR}/xgl.py
)
- add_library(XGLLayer${target} SHARED ${ARGN} XGLLayer${target}.def)
- target_link_Libraries(XGLLayer${target} layer_utils)
- add_dependencies(XGLLayer${target} generate_xgl_layer_helpers)
- add_dependencies(XGLLayer${target} ${CMAKE_CURRENT_BINARY_DIR}/XGLLayer${target}.def)
- set_target_properties(XGLLayer${target} PROPERTIES LINK_FLAGS "/DEF:${CMAKE_CURRENT_BINARY_DIR}/XGLLayer${target}.def")
+ add_library(VKLayer${target} SHARED ${ARGN} VKLayer${target}.def)
+ target_link_Libraries(VKLayer${target} layer_utils)
+ add_dependencies(VKLayer${target} generate_vk_layer_helpers)
+ add_dependencies(VKLayer${target} ${CMAKE_CURRENT_BINARY_DIR}/VKLayer${target}.def)
+ set_target_properties(VKLayer${target} PROPERTIES LINK_FLAGS "/DEF:${CMAKE_CURRENT_BINARY_DIR}/VKLayer${target}.def")
endmacro()
else()
- macro(add_xgl_layer target)
- add_library(XGLLayer${target} SHARED ${ARGN})
- target_link_Libraries(XGLLayer${target} layer_utils)
- add_dependencies(XGLLayer${target} generate_xgl_layer_helpers)
- set_target_properties(XGLLayer${target} PROPERTIES LINK_FLAGS "-Wl,-Bsymbolic")
+ macro(add_vk_layer target)
+ add_library(VKLayer${target} SHARED ${ARGN})
+ target_link_Libraries(VKLayer${target} layer_utils)
+ add_dependencies(VKLayer${target} generate_vk_layer_helpers)
+ set_target_properties(VKLayer${target} PROPERTIES LINK_FLAGS "-Wl,-Bsymbolic")
endmacro()
endif()
@@ -42,58 +42,58 @@
)
if (WIN32)
- set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DXGL_PROTOTYPES -D_CRT_SECURE_NO_WARNINGS")
- set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DXGL_PROTOTYPES -D_CRT_SECURE_NO_WARNINGS")
+ set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVK_PROTOTYPES -D_CRT_SECURE_NO_WARNINGS")
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DVK_PROTOTYPES -D_CRT_SECURE_NO_WARNINGS")
endif()
if (NOT WIN32)
set (CMAKE_CXX_FLAGS "-std=c++11")
- set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DXGL_PROTOTYPES -Wpointer-arith")
- set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DXGL_PROTOTYPES -Wpointer-arith")
+ set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVK_PROTOTYPES -Wpointer-arith")
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DVK_PROTOTYPES -Wpointer-arith")
endif()
-add_custom_command(OUTPUT xgl_dispatch_table_helper.h
- COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py dispatch-table-ops layer > xgl_dispatch_table_helper.h
+add_custom_command(OUTPUT vk_dispatch_table_helper.h
+ COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py dispatch-table-ops layer > vk_dispatch_table_helper.h
DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py ${PROJECT_SOURCE_DIR}/xgl.py)
-add_custom_command(OUTPUT xgl_generic_intercept_proc_helper.h
- COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py layer-intercept-proc > xgl_generic_intercept_proc_helper.h
+add_custom_command(OUTPUT vk_generic_intercept_proc_helper.h
+ COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py layer-intercept-proc > vk_generic_intercept_proc_helper.h
DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py ${PROJECT_SOURCE_DIR}/xgl.py)
-run_xgl_helper(gen_enum_string_helper xgl_enum_string_helper.h)
-run_xgl_helper(gen_struct_wrappers
- xgl_struct_string_helper.h
- xgl_struct_string_helper_cpp.h
- xgl_struct_string_helper_no_addr.h
- xgl_struct_string_helper_no_addr_cpp.h
- xgl_struct_size_helper.h
- xgl_struct_size_helper.c
- xgl_struct_wrappers.h
- xgl_struct_wrappers.cpp
+run_vk_helper(gen_enum_string_helper vk_enum_string_helper.h)
+run_vk_helper(gen_struct_wrappers
+ vk_struct_string_helper.h
+ vk_struct_string_helper_cpp.h
+ vk_struct_string_helper_no_addr.h
+ vk_struct_string_helper_no_addr_cpp.h
+ vk_struct_size_helper.h
+ vk_struct_size_helper.c
+ vk_struct_wrappers.h
+ vk_struct_wrappers.cpp
)
-run_xgl_helper(gen_graphviz xgl_struct_graphviz_helper.h)
+run_vk_helper(gen_graphviz vk_struct_graphviz_helper.h)
-add_custom_target(generate_xgl_layer_helpers DEPENDS
- xgl_dispatch_table_helper.h
- xgl_generic_intercept_proc_helper.h
- xgl_enum_string_helper.h
- xgl_struct_string_helper.h
- xgl_struct_string_helper_no_addr.h
- xgl_struct_string_helper_cpp.h
- xgl_struct_string_helper_no_addr_cpp.h
- xgl_struct_size_helper.h
- xgl_struct_size_helper.c
- xgl_struct_wrappers.h
- xgl_struct_wrappers.cpp
- xgl_struct_graphviz_helper.h
+add_custom_target(generate_vk_layer_helpers DEPENDS
+ vk_dispatch_table_helper.h
+ vk_generic_intercept_proc_helper.h
+ vk_enum_string_helper.h
+ vk_struct_string_helper.h
+ vk_struct_string_helper_no_addr.h
+ vk_struct_string_helper_cpp.h
+ vk_struct_string_helper_no_addr_cpp.h
+ vk_struct_size_helper.h
+ vk_struct_size_helper.c
+ vk_struct_wrappers.h
+ vk_struct_wrappers.cpp
+ vk_struct_graphviz_helper.h
)
-run_xgl_layer_generate(Generic generic_layer.c)
-run_xgl_layer_generate(ApiDump api_dump.c)
-run_xgl_layer_generate(ApiDumpFile api_dump_file.c)
-run_xgl_layer_generate(ApiDumpNoAddr api_dump_no_addr.c)
-run_xgl_layer_generate(ApiDumpCpp api_dump.cpp)
-run_xgl_layer_generate(ApiDumpNoAddrCpp api_dump_no_addr.cpp)
-run_xgl_layer_generate(ObjectTracker object_track.c)
+run_vk_layer_generate(Generic generic_layer.c)
+run_vk_layer_generate(ApiDump api_dump.c)
+run_vk_layer_generate(ApiDumpFile api_dump_file.c)
+run_vk_layer_generate(ApiDumpNoAddr api_dump_no_addr.c)
+run_vk_layer_generate(ApiDumpCpp api_dump.cpp)
+run_vk_layer_generate(ApiDumpNoAddrCpp api_dump_no_addr.cpp)
+run_vk_layer_generate(ObjectTracker object_track.c)
add_library(layer_utils SHARED layers_config.cpp)
if (WIN32)
@@ -102,17 +102,17 @@
target_link_libraries(layer_utils)
endif()
-add_xgl_layer(Basic basic.cpp)
-add_xgl_layer(Multi multi.cpp)
-add_xgl_layer(DrawState draw_state.cpp)
-add_xgl_layer(MemTracker mem_tracker.cpp)
-add_xgl_layer(GlaveSnapshot glave_snapshot.c)
+add_vk_layer(Basic basic.cpp)
+add_vk_layer(Multi multi.cpp)
+add_vk_layer(DrawState draw_state.cpp)
+add_vk_layer(MemTracker mem_tracker.cpp)
+add_vk_layer(GlaveSnapshot glave_snapshot.c)
# generated
-add_xgl_layer(Generic generic_layer.c)
-add_xgl_layer(APIDump api_dump.c)
-add_xgl_layer(APIDumpFile api_dump_file.c)
-add_xgl_layer(APIDumpNoAddr api_dump_no_addr.c)
-add_xgl_layer(APIDumpCpp api_dump.cpp)
-add_xgl_layer(APIDumpNoAddrCpp api_dump_no_addr.cpp)
-add_xgl_layer(ObjectTracker object_track.c)
-add_xgl_layer(ParamChecker param_checker.cpp)
+add_vk_layer(Generic generic_layer.c)
+add_vk_layer(APIDump api_dump.c)
+add_vk_layer(APIDumpFile api_dump_file.c)
+add_vk_layer(APIDumpNoAddr api_dump_no_addr.c)
+add_vk_layer(APIDumpCpp api_dump.cpp)
+add_vk_layer(APIDumpNoAddrCpp api_dump_no_addr.cpp)
+add_vk_layer(ObjectTracker object_track.c)
+add_vk_layer(ParamChecker param_checker.cpp)
diff --git a/layers/README.md b/layers/README.md
index 21ce969..449f892 100644
--- a/layers/README.md
+++ b/layers/README.md
@@ -2,13 +2,13 @@
## Overview
-Layer libraries can be written to intercept or hook XGL entrypoints for various
-debug and validation purposes. One or more XGL entrypoints can be defined in your Layer
+Layer libraries can be written to intercept or hook VK entrypoints for various
+debug and validation purposes. One or more VK entrypoints can be defined in your Layer
library. Undefined entrypoints in the Layer library will be passed to the next Layer which
may be the driver. Multiple layer libraries can be chained (actually a hierarchy) together.
-xglEnumerateLayer can be called to list the available layer libraries. xglGetProcAddr is
+vkEnumerateLayer can be called to list the available layer libraries. vkGetProcAddr is
used internally by the Layers and ICD Loader to initialize dispatch tables. Layers are
-activated at xglCreateDevice time. xglCreateDevice createInfo struct is extended to allow
+activated at vkCreateDevice time. vkCreateDevice createInfo struct is extended to allow
a list of layers to be activated. Layer libraries can alternatively be LD\_PRELOADed depending
upon how they are implemented.
@@ -16,33 +16,33 @@
Note that some layers are code-generated and will therefore exist in the directory (build_dir)/layers
--include/xglLayer.h - header file for layer code.
+-include/vkLayer.h - header file for layer code.
### Templates
layer/Basic.cpp (name=Basic) simple example wrapping a few entrypoints. Shows layer features:
- Multiple dispatch tables for supporting multiple GPUs.
- Example layer extension function shown.
-- Layer extension advertised by xglGetExtension().
-- xglEnumerateLayers() supports loader layer name queries and call interception
+- Layer extension advertised by vkGetExtension().
+- vkEnumerateLayers() supports loader layer name queries and call interception
- Can be LD\_PRELOADed individually
layer/Multi.cpp (name=multi1:multi2) simple example showing multiple layers per library
-(build dir)/layer/generic_layer.c (name=Generic) - auto generated example wrapping all XGL entrypoints. Single global dispatch table. Can be LD\_PRELOADed.
+(build dir)/layer/generic_layer.c (name=Generic) - auto generated example wrapping all VK entrypoints. Single global dispatch table. Can be LD\_PRELOADed.
### Print API Calls and Parameter Values
(build dir)/layer/api_dump.c (name=APIDump) - print out API calls along with parameter values
(build dir)/layer/api_dump.cpp (name=APIDumpCpp) - same as above but uses c++ strings and i/o streams
-(build dir)/layer/api\_dump\_file.c (name=APIDumpFile) - Write API calls along with parameter values to xgl\_apidump.txt file.
+(build dir)/layer/api\_dump\_file.c (name=APIDumpFile) - Write API calls along with parameter values to vk\_apidump.txt file.
(build dir)/layer/api\_dump\_no\_addr.c (name=APIDumpNoAddr) - print out API calls along with parameter values but replace any variable addresses with the static string "addr".
(build dir)/layer/api\_dump\_no\_addr.cpp (name=APIDumpNoAddrCpp) - same as above but uses c++ strings and i/o streams
### Print Object Stats
-(build dir>/layer/object_track.c (name=ObjectTracker) - Print object CREATE/USE/DESTROY stats. Individually track objects by category. XGL\_OBJECT\_TYPE enum defined in object_track.h. If a Dbg callback function is registered, this layer will use callback function(s) for reporting, otherwise uses stdout. Provides custom interface to query number of live objects of given type "XGL\_UINT64 objTrackGetObjectCount(XGL\_OBJECT\_TYPE type)" and a secondary call to return an array of those objects "XGL\_RESULT objTrackGetObjects(XGL\_OBJECT\_TYPE type, XGL\_UINT64 objCount, OBJTRACK\_NODE* pObjNodeArray)".
+(build dir>/layer/object_track.c (name=ObjectTracker) - Print object CREATE/USE/DESTROY stats. Individually track objects by category. VK\_OBJECT\_TYPE enum defined in object_track.h. If a Dbg callback function is registered, this layer will use callback function(s) for reporting, otherwise uses stdout. Provides custom interface to query number of live objects of given type "VK\_UINT64 objTrackGetObjectCount(VK\_OBJECT\_TYPE type)" and a secondary call to return an array of those objects "VK\_RESULT objTrackGetObjects(VK\_OBJECT\_TYPE type, VK\_UINT64 objCount, OBJTRACK\_NODE* pObjNodeArray)".
### Report Draw State
layer/draw\_state.c (name=DrawState) - DrawState reports the Descriptor Set, Pipeline State, and dynamic state at each Draw call. DrawState layer performs a number of validation checks on this state. Of primary interest is making sure that the resources bound to Descriptor Sets correctly align with the layout specified for the Set. If a Dbg callback function is registered, this layer will use callback function(s) for reporting, otherwise uses stdout.
@@ -55,62 +55,62 @@
## Using Layers
-1. Build XGL loader and i965 icd driver using normal steps (cmake and make)
-2. Place libXGLLayer<name>.so in the same directory as your XGL test or app:
+1. Build VK loader and i965 icd driver using normal steps (cmake and make)
+2. Place libVKLayer<name>.so in the same directory as your VK test or app:
- cp build/layer/libXGLLayerBasic.so build/layer/libXGLLayerGeneric.so build/tests
+ cp build/layer/libVKLayerBasic.so build/layer/libVKLayerGeneric.so build/tests
- This is required for the Icd loader to be able to scan and enumerate your library. Alternatively, use the LIBXGL\_LAYERS\_PATH environment variable to specify where the layer libraries reside.
+ This is required for the Icd loader to be able to scan and enumerate your library. Alternatively, use the LIBVK\_LAYERS\_PATH environment variable to specify where the layer libraries reside.
3. Specify which Layers to activate by using
-xglCreateDevice XGL\_LAYER\_CREATE\_INFO struct or environment variable LIBXGL\_LAYER\_NAMES
+vkCreateDevice VK\_LAYER\_CREATE\_INFO struct or environment variable LIBVK\_LAYER\_NAMES
- export LIBXGL\_LAYER\_NAMES=Basic:Generic
- cd build/tests; ./xglinfo
+ export LIBVK\_LAYER\_NAMES=Basic:Generic
+ cd build/tests; ./vkinfo
## Tips for writing new layers
-1. Must implement xglGetProcAddr() (aka GPA);
-2. Must have a local dispatch table to call next layer (see xglLayer.h);
-3. Should implement xglEnumerateLayers() returning layer name when gpu == NULL; otherwise layer name is extracted from library filename by the Loader;
+1. Must implement vkGetProcAddr() (aka GPA);
+2. Must have a local dispatch table to call next layer (see vkLayer.h);
+3. Should implement vkEnumerateLayers() returning layer name when gpu == NULL; otherwise layer name is extracted from library filename by the Loader;
4. gpu objects must be unwrapped (gpu->nextObject) when passed to next layer;
5. next layers GPA can be found in the wrapped gpu object;
6. Loader calls a layer's GPA first so initialization should occur here;
7. all entrypoints can be wrapped but only will be called after layer is activated
- via the first xglCreatDevice;
-8. entrypoint names can be any name as specified by the layers xglGetProcAddr
- implementation; exceptions are xglGetProcAddr and xglEnumerateLayers,
+ via the first vkCreatDevice;
+8. entrypoint names can be any name as specified by the layers vkGetProcAddr
+ implementation; exceptions are vkGetProcAddr and vkEnumerateLayers,
which must have the correct name since the Loader calls these entrypoints;
-9. entrypoint names must be exported to the dynamic loader with XGL\_LAYER\_EXPORT;
-10. For LD\_PRELOAD support: a)entrypoint names should be offical xgl names and
+9. entrypoint names must be exported to the dynamic loader with VK\_LAYER\_EXPORT;
+10. For LD\_PRELOAD support: a)entrypoint names should be offical vk names and
b) initialization should occur on any call with a gpu object (Loader type
- initialization must be done if implementing xglInitAndEnumerateGpus).
-11. Implement xglGetExtension() if you want to advertise a layer extension
+ initialization must be done if implementing vkInitAndEnumerateGpus).
+11. Implement vkGetExtension() if you want to advertise a layer extension
(only available after the layer is activated);
-12. Layer naming convention is camel case same name as in library: libXGLLayer<name>.so
+12. Layer naming convention is camel case same name as in library: libVKLayer<name>.so
13. For multiple layers in one library should implement a separate GetProcAddr for each
layer and export them to dynamic loader; function name is <layerName>GetProcAddr().
- Main xglGetProcAddr() should also be implemented.
+ Main vkGetProcAddr() should also be implemented.
## Status
### Current Features
-- scanning of available Layers during xglInitAndEnumerateGpus;
-- layer names retrieved via xglEnumerateLayers();
-- xglEnumerateLayers and xglGetProcAddr supported APIs in xgl.h, ICD loader and i965 driver;
+- scanning of available Layers during vkInitAndEnumerateGpus;
+- layer names retrieved via vkEnumerateLayers();
+- vkEnumerateLayers and vkGetProcAddr supported APIs in vulkan.h, ICD loader and i965 driver;
- multiple layers in a hierarchy supported;
- layer enumeration supported per GPU;
- layers activated per gpu and per icd driver: separate dispatch table and layer library list in loader for each gpu or icd driver;
-- activation via xglCreateDevice extension struct in CreateInfo or via env var (LIBXGL\_LAYER\_NAMES);
+- activation via vkCreateDevice extension struct in CreateInfo or via env var (LIBVK\_LAYER\_NAMES);
- layer libraries can be LD\_PRELOADed if implemented correctly;
### Current known issues
- Layers with multiple threads are not well tested and some layers likely to have issues. APIDump family of layers should be thread-safe.
- layer libraries (except Basic) don't support multiple dispatch tables for multi-gpus;
-- layer libraries not yet include loader init functionality for full LD\_PRELOAD of entire API including xglInitAndEnumerateGpus;
-- Since Layers aren't activated until xglCreateDevice, any calls to xglGetExtension() will not report layer extensions unless implemented in the layer;
-- layer extensions do NOT need to be enabled in xglCreateDevice to be available;
+- layer libraries not yet include loader init functionality for full LD\_PRELOAD of entire API including vkInitAndEnumerateGpus;
+- Since Layers aren't activated until vkCreateDevice, any calls to vkGetExtension() will not report layer extensions unless implemented in the layer;
+- layer extensions do NOT need to be enabled in vkCreateDevice to be available;
- no support for apps registering layers, must be discovered via initial scan
diff --git a/layers/basic.cpp b/layers/basic.cpp
index 627dc87..dbbb491 100644
--- a/layers/basic.cpp
+++ b/layers/basic.cpp
@@ -1,5 +1,5 @@
/*
- * XGL
+ * Vulkan
*
* Copyright (C) 2014 LunarG, Inc.
*
@@ -26,110 +26,110 @@
#include <assert.h>
#include <unordered_map>
#include "loader_platform.h"
-#include "xgl_dispatch_table_helper.h"
-#include "xglLayer.h"
+#include "vk_dispatch_table_helper.h"
+#include "vkLayer.h"
// The following is #included again to catch certain OS-specific functions
// being used:
#include "loader_platform.h"
-static std::unordered_map<void *, XGL_LAYER_DISPATCH_TABLE *> tableMap;
+static std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *> tableMap;
-static XGL_LAYER_DISPATCH_TABLE * initLayerTable(const XGL_BASE_LAYER_OBJECT *gpuw)
+static VK_LAYER_DISPATCH_TABLE * initLayerTable(const VK_BASE_LAYER_OBJECT *gpuw)
{
- XGL_LAYER_DISPATCH_TABLE *pTable;
+ VK_LAYER_DISPATCH_TABLE *pTable;
assert(gpuw);
- std::unordered_map<void *, XGL_LAYER_DISPATCH_TABLE *>::const_iterator it = tableMap.find((void *) gpuw);
+ std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *>::const_iterator it = tableMap.find((void *) gpuw);
if (it == tableMap.end())
{
- pTable = new XGL_LAYER_DISPATCH_TABLE;
+ pTable = new VK_LAYER_DISPATCH_TABLE;
tableMap[(void *) gpuw] = pTable;
} else
{
return it->second;
}
- layer_initialize_dispatch_table(pTable, gpuw->pGPA, (XGL_PHYSICAL_GPU) gpuw->nextObject);
+ layer_initialize_dispatch_table(pTable, gpuw->pGPA, (VK_PHYSICAL_GPU) gpuw->nextObject);
return pTable;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglLayerExtension1(XGL_DEVICE device)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkLayerExtension1(VK_DEVICE device)
{
- printf("In xglLayerExtension1() call w/ device: %p\n", (void*)device);
- printf("xglLayerExtension1 returning SUCCESS\n");
- return XGL_SUCCESS;
+ printf("In vkLayerExtension1() call w/ device: %p\n", (void*)device);
+ printf("vkLayerExtension1 returning SUCCESS\n");
+ return VK_SUCCESS;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu, const char* pExtName)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName)
{
- XGL_RESULT result;
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_RESULT result;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
/* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */
- if (!strncmp(pExtName, "xglLayerExtension1", strlen("xglLayerExtension1")))
+ if (!strncmp(pExtName, "vkLayerExtension1", strlen("vkLayerExtension1")))
{
- result = XGL_SUCCESS;
+ result = VK_SUCCESS;
} else if (!strncmp(pExtName, "Basic", strlen("Basic")))
{
- result = XGL_SUCCESS;
+ result = VK_SUCCESS;
} else if (!tableMap.empty() && (tableMap.find(gpuw) != tableMap.end()))
{
- printf("At start of wrapped xglGetExtensionSupport() call w/ gpu: %p\n", (void*)gpu);
- XGL_LAYER_DISPATCH_TABLE* pTable = tableMap[gpuw];
- result = pTable->GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);
- printf("Completed wrapped xglGetExtensionSupport() call w/ gpu: %p\n", (void*)gpu);
+ printf("At start of wrapped vkGetExtensionSupport() call w/ gpu: %p\n", (void*)gpu);
+ VK_LAYER_DISPATCH_TABLE* pTable = tableMap[gpuw];
+ result = pTable->GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);
+ printf("Completed wrapped vkGetExtensionSupport() call w/ gpu: %p\n", (void*)gpu);
} else
{
- result = XGL_ERROR_INVALID_EXTENSION;
+ result = VK_ERROR_INVALID_EXTENSION;
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
- XGL_LAYER_DISPATCH_TABLE* pTable = tableMap[gpuw];
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+ VK_LAYER_DISPATCH_TABLE* pTable = tableMap[gpuw];
- printf("At start of wrapped xglCreateDevice() call w/ gpu: %p\n", (void*)gpu);
- XGL_RESULT result = pTable->CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
+ printf("At start of wrapped vkCreateDevice() call w/ gpu: %p\n", (void*)gpu);
+ VK_RESULT result = pTable->CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
// create a mapping for the device object into the dispatch table
tableMap.emplace(*pDevice, pTable);
- printf("Completed wrapped xglCreateDevice() call w/ pDevice, Device %p: %p\n", (void*)pDevice, (void *) *pDevice);
+ printf("Completed wrapped vkCreateDevice() call w/ pDevice, Device %p: %p\n", (void*)pDevice, (void *) *pDevice);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFormatInfo(XGL_DEVICE device, XGL_FORMAT format, XGL_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFormatInfo(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
{
- XGL_LAYER_DISPATCH_TABLE* pTable = tableMap[device];
+ VK_LAYER_DISPATCH_TABLE* pTable = tableMap[device];
- printf("At start of wrapped xglGetFormatInfo() call w/ device: %p\n", (void*)device);
- XGL_RESULT result = pTable->GetFormatInfo(device, format, infoType, pDataSize, pData);
- printf("Completed wrapped xglGetFormatInfo() call w/ device: %p\n", (void*)device);
+ printf("At start of wrapped vkGetFormatInfo() call w/ device: %p\n", (void*)device);
+ VK_RESULT result = pTable->GetFormatInfo(device, format, infoType, pDataSize, pData);
+ printf("Completed wrapped vkGetFormatInfo() call w/ device: %p\n", (void*)device);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
{
if (gpu != NULL)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
- XGL_LAYER_DISPATCH_TABLE* pTable = initLayerTable(gpuw);
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+ VK_LAYER_DISPATCH_TABLE* pTable = initLayerTable(gpuw);
- printf("At start of wrapped xglEnumerateLayers() call w/ gpu: %p\n", gpu);
- XGL_RESULT result = pTable->EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+ printf("At start of wrapped vkEnumerateLayers() call w/ gpu: %p\n", gpu);
+ VK_RESULT result = pTable->EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
return result;
} else
{
if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL || pReserved == NULL)
- return XGL_ERROR_INVALID_POINTER;
+ return VK_ERROR_INVALID_POINTER;
// Example of a layer that is only compatible with Intel's GPUs
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT*) pReserved;
- xglGetGpuInfoType fpGetGpuInfo;
- XGL_PHYSICAL_GPU_PROPERTIES gpuProps;
- size_t dataSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);
- fpGetGpuInfo = (xglGetGpuInfoType) gpuw->pGPA((XGL_PHYSICAL_GPU) gpuw->nextObject, "xglGetGpuInfo");
- fpGetGpuInfo((XGL_PHYSICAL_GPU) gpuw->nextObject, XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &dataSize, &gpuProps);
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT*) pReserved;
+ vkGetGpuInfoType fpGetGpuInfo;
+ VK_PHYSICAL_GPU_PROPERTIES gpuProps;
+ size_t dataSize = sizeof(VK_PHYSICAL_GPU_PROPERTIES);
+ fpGetGpuInfo = (vkGetGpuInfoType) gpuw->pGPA((VK_PHYSICAL_GPU) gpuw->nextObject, "vkGetGpuInfo");
+ fpGetGpuInfo((VK_PHYSICAL_GPU) gpuw->nextObject, VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &dataSize, &gpuProps);
if (gpuProps.vendorId == 0x8086)
{
*pOutLayerCount = 1;
@@ -138,33 +138,33 @@
{
*pOutLayerCount = 0;
}
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
}
-XGL_LAYER_EXPORT void * XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* pName)
+VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* pName)
{
if (gpu == NULL)
return NULL;
- initLayerTable((const XGL_BASE_LAYER_OBJECT *) gpu);
+ initLayerTable((const VK_BASE_LAYER_OBJECT *) gpu);
- if (!strncmp("xglGetProcAddr", pName, sizeof("xglGetProcAddr")))
- return (void *) xglGetProcAddr;
- else if (!strncmp("xglCreateDevice", pName, sizeof ("xglCreateDevice")))
- return (void *) xglCreateDevice;
- else if (!strncmp("xglGetExtensionSupport", pName, sizeof ("xglGetExtensionSupport")))
- return (void *) xglGetExtensionSupport;
- else if (!strncmp("xglEnumerateLayers", pName, sizeof ("xglEnumerateLayers")))
- return (void *) xglEnumerateLayers;
- else if (!strncmp("xglGetFormatInfo", pName, sizeof ("xglGetFormatInfo")))
- return (void *) xglGetFormatInfo;
- else if (!strncmp("xglLayerExtension1", pName, sizeof("xglLayerExtension1")))
- return (void *) xglLayerExtension1;
+ if (!strncmp("vkGetProcAddr", pName, sizeof("vkGetProcAddr")))
+ return (void *) vkGetProcAddr;
+ else if (!strncmp("vkCreateDevice", pName, sizeof ("vkCreateDevice")))
+ return (void *) vkCreateDevice;
+ else if (!strncmp("vkGetExtensionSupport", pName, sizeof ("vkGetExtensionSupport")))
+ return (void *) vkGetExtensionSupport;
+ else if (!strncmp("vkEnumerateLayers", pName, sizeof ("vkEnumerateLayers")))
+ return (void *) vkEnumerateLayers;
+ else if (!strncmp("vkGetFormatInfo", pName, sizeof ("vkGetFormatInfo")))
+ return (void *) vkGetFormatInfo;
+ else if (!strncmp("vkLayerExtension1", pName, sizeof("vkLayerExtension1")))
+ return (void *) vkLayerExtension1;
else {
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
if (gpuw->pGPA == NULL)
return NULL;
- return gpuw->pGPA((XGL_PHYSICAL_GPU) gpuw->nextObject, pName);
+ return gpuw->pGPA((VK_PHYSICAL_GPU) gpuw->nextObject, pName);
}
}
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index 503c08a..53ec6cd 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -1,5 +1,5 @@
/*
- * XGL
+ * Vulkan
*
* Copyright (C) 2014 LunarG, Inc.
*
@@ -28,12 +28,12 @@
#include <unordered_map>
#include "loader_platform.h"
-#include "xgl_dispatch_table_helper.h"
-#include "xgl_struct_string_helper_cpp.h"
+#include "vk_dispatch_table_helper.h"
+#include "vk_struct_string_helper_cpp.h"
#pragma GCC diagnostic ignored "-Wwrite-strings"
-#include "xgl_struct_graphviz_helper.h"
+#include "vk_struct_graphviz_helper.h"
#pragma GCC diagnostic warning "-Wwrite-strings"
-#include "xgl_struct_size_helper.h"
+#include "vk_struct_size_helper.h"
#include "draw_state.h"
#include "layers_config.h"
// The following is #included again to catch certain OS-specific functions
@@ -41,21 +41,21 @@
#include "loader_platform.h"
#include "layers_msg.h"
-unordered_map<XGL_SAMPLER, SAMPLER_NODE*> sampleMap;
-unordered_map<XGL_IMAGE_VIEW, IMAGE_NODE*> imageMap;
-unordered_map<XGL_BUFFER_VIEW, BUFFER_NODE*> bufferMap;
-unordered_map<XGL_DYNAMIC_STATE_OBJECT, DYNAMIC_STATE_NODE*> dynamicStateMap;
-unordered_map<XGL_PIPELINE, PIPELINE_NODE*> pipelineMap;
-unordered_map<XGL_DESCRIPTOR_POOL, POOL_NODE*> poolMap;
-unordered_map<XGL_DESCRIPTOR_SET, SET_NODE*> setMap;
-unordered_map<XGL_DESCRIPTOR_SET_LAYOUT, LAYOUT_NODE*> layoutMap;
+unordered_map<VK_SAMPLER, SAMPLER_NODE*> sampleMap;
+unordered_map<VK_IMAGE_VIEW, IMAGE_NODE*> imageMap;
+unordered_map<VK_BUFFER_VIEW, BUFFER_NODE*> bufferMap;
+unordered_map<VK_DYNAMIC_STATE_OBJECT, DYNAMIC_STATE_NODE*> dynamicStateMap;
+unordered_map<VK_PIPELINE, PIPELINE_NODE*> pipelineMap;
+unordered_map<VK_DESCRIPTOR_POOL, POOL_NODE*> poolMap;
+unordered_map<VK_DESCRIPTOR_SET, SET_NODE*> setMap;
+unordered_map<VK_DESCRIPTOR_SET_LAYOUT, LAYOUT_NODE*> layoutMap;
// Map for layout chains
-unordered_map<XGL_CMD_BUFFER, GLOBAL_CB_NODE*> cmdBufferMap;
-unordered_map<XGL_RENDER_PASS, XGL_RENDER_PASS_CREATE_INFO*> renderPassMap;
-unordered_map<XGL_FRAMEBUFFER, XGL_FRAMEBUFFER_CREATE_INFO*> frameBufferMap;
+unordered_map<VK_CMD_BUFFER, GLOBAL_CB_NODE*> cmdBufferMap;
+unordered_map<VK_RENDER_PASS, VK_RENDER_PASS_CREATE_INFO*> renderPassMap;
+unordered_map<VK_FRAMEBUFFER, VK_FRAMEBUFFER_CREATE_INFO*> frameBufferMap;
-static XGL_LAYER_DISPATCH_TABLE nextTable;
-static XGL_BASE_LAYER_OBJECT *pCurObj;
+static VK_LAYER_DISPATCH_TABLE nextTable;
+static VK_BASE_LAYER_OBJECT *pCurObj;
static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_initOnce);
// TODO : This can be much smarter, using separate locks for separate global data
static int globalLockInitialized = 0;
@@ -171,7 +171,7 @@
}
// Block of code at start here for managing/tracking Pipeline state that this layer cares about
// Just track 2 shaders for now
-#define XGL_NUM_GRAPHICS_SHADERS XGL_SHADER_STAGE_COMPUTE
+#define VK_NUM_GRAPHICS_SHADERS VK_SHADER_STAGE_COMPUTE
#define MAX_SLOTS 2048
#define NUM_COMMAND_BUFFERS_TO_DISPLAY 10
@@ -181,46 +181,46 @@
// Then need to synchronize the accesses based on cmd buffer so that if I'm reading state on one cmd buffer, updates
// to that same cmd buffer by separate thread are not changing state from underneath us
// Track the last cmd buffer touched by this thread
-static XGL_CMD_BUFFER g_lastCmdBuffer[MAX_TID] = {NULL};
+static VK_CMD_BUFFER g_lastCmdBuffer[MAX_TID] = {NULL};
// Track the last group of CBs touched for displaying to dot file
static GLOBAL_CB_NODE* g_pLastTouchedCB[NUM_COMMAND_BUFFERS_TO_DISPLAY] = {NULL};
static uint32_t g_lastTouchedCBIndex = 0;
// Track the last global DrawState of interest touched by any thread
static GLOBAL_CB_NODE* g_lastGlobalCB = NULL;
static PIPELINE_NODE* g_lastBoundPipeline = NULL;
-static DYNAMIC_STATE_NODE* g_lastBoundDynamicState[XGL_NUM_STATE_BIND_POINT] = {NULL};
-static XGL_DESCRIPTOR_SET g_lastBoundDescriptorSet = NULL;
+static DYNAMIC_STATE_NODE* g_lastBoundDynamicState[VK_NUM_STATE_BIND_POINT] = {NULL};
+static VK_DESCRIPTOR_SET g_lastBoundDescriptorSet = NULL;
#define MAX_BINDING 0xFFFFFFFF // Default vtxBinding value in CB Node to identify if no vtxBinding set
-//static DYNAMIC_STATE_NODE* g_pDynamicStateHead[XGL_NUM_STATE_BIND_POINT] = {0};
+//static DYNAMIC_STATE_NODE* g_pDynamicStateHead[VK_NUM_STATE_BIND_POINT] = {0};
-static void insertDynamicState(const XGL_DYNAMIC_STATE_OBJECT state, const GENERIC_HEADER* pCreateInfo, XGL_STATE_BIND_POINT bindPoint)
+static void insertDynamicState(const VK_DYNAMIC_STATE_OBJECT state, const GENERIC_HEADER* pCreateInfo, VK_STATE_BIND_POINT bindPoint)
{
- XGL_DYNAMIC_VP_STATE_CREATE_INFO* pVPCI = NULL;
+ VK_DYNAMIC_VP_STATE_CREATE_INFO* pVPCI = NULL;
size_t scSize = 0;
size_t vpSize = 0;
loader_platform_thread_lock_mutex(&globalLock);
DYNAMIC_STATE_NODE* pStateNode = new DYNAMIC_STATE_NODE;
pStateNode->stateObj = state;
switch (pCreateInfo->sType) {
- case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
- memcpy(&pStateNode->create_info, pCreateInfo, sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO));
- pVPCI = (XGL_DYNAMIC_VP_STATE_CREATE_INFO*)pCreateInfo;
- pStateNode->create_info.vpci.pScissors = new XGL_RECT[pStateNode->create_info.vpci.viewportAndScissorCount];
- pStateNode->create_info.vpci.pViewports = new XGL_VIEWPORT[pStateNode->create_info.vpci.viewportAndScissorCount];
- scSize = pVPCI->viewportAndScissorCount * sizeof(XGL_RECT);
- vpSize = pVPCI->viewportAndScissorCount * sizeof(XGL_VIEWPORT);
+ case VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
+ memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VK_DYNAMIC_VP_STATE_CREATE_INFO));
+ pVPCI = (VK_DYNAMIC_VP_STATE_CREATE_INFO*)pCreateInfo;
+ pStateNode->create_info.vpci.pScissors = new VK_RECT[pStateNode->create_info.vpci.viewportAndScissorCount];
+ pStateNode->create_info.vpci.pViewports = new VK_VIEWPORT[pStateNode->create_info.vpci.viewportAndScissorCount];
+ scSize = pVPCI->viewportAndScissorCount * sizeof(VK_RECT);
+ vpSize = pVPCI->viewportAndScissorCount * sizeof(VK_VIEWPORT);
memcpy((void*)pStateNode->create_info.vpci.pScissors, pVPCI->pScissors, scSize);
memcpy((void*)pStateNode->create_info.vpci.pViewports, pVPCI->pViewports, vpSize);
break;
- case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
- memcpy(&pStateNode->create_info, pCreateInfo, sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO));
+ case VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
+ memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VK_DYNAMIC_RS_STATE_CREATE_INFO));
break;
- case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
- memcpy(&pStateNode->create_info, pCreateInfo, sizeof(XGL_DYNAMIC_CB_STATE_CREATE_INFO));
+ case VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
+ memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VK_DYNAMIC_CB_STATE_CREATE_INFO));
break;
- case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
- memcpy(&pStateNode->create_info, pCreateInfo, sizeof(XGL_DYNAMIC_DS_STATE_CREATE_INFO));
+ case VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
+ memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VK_DYNAMIC_DS_STATE_CREATE_INFO));
break;
default:
assert(0);
@@ -233,8 +233,8 @@
// Free all allocated nodes for Dynamic State objs
static void freeDynamicState()
{
- for (unordered_map<XGL_DYNAMIC_STATE_OBJECT, DYNAMIC_STATE_NODE*>::iterator ii=dynamicStateMap.begin(); ii!=dynamicStateMap.end(); ++ii) {
- if (XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO == (*ii).second->create_info.vpci.sType) {
+ for (unordered_map<VK_DYNAMIC_STATE_OBJECT, DYNAMIC_STATE_NODE*>::iterator ii=dynamicStateMap.begin(); ii!=dynamicStateMap.end(); ++ii) {
+ if (VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO == (*ii).second->create_info.vpci.sType) {
delete[] (*ii).second->create_info.vpci.pScissors;
delete[] (*ii).second->create_info.vpci.pViewports;
}
@@ -244,11 +244,11 @@
// Free all sampler nodes
static void freeSamplers()
{
- for (unordered_map<XGL_SAMPLER, SAMPLER_NODE*>::iterator ii=sampleMap.begin(); ii!=sampleMap.end(); ++ii) {
+ for (unordered_map<VK_SAMPLER, SAMPLER_NODE*>::iterator ii=sampleMap.begin(); ii!=sampleMap.end(); ++ii) {
delete (*ii).second;
}
}
-static XGL_IMAGE_VIEW_CREATE_INFO* getImageViewCreateInfo(XGL_IMAGE_VIEW view)
+static VK_IMAGE_VIEW_CREATE_INFO* getImageViewCreateInfo(VK_IMAGE_VIEW view)
{
loader_platform_thread_lock_mutex(&globalLock);
if (imageMap.find(view) == imageMap.end()) {
@@ -263,11 +263,11 @@
// Free all image nodes
static void freeImages()
{
- for (unordered_map<XGL_IMAGE_VIEW, IMAGE_NODE*>::iterator ii=imageMap.begin(); ii!=imageMap.end(); ++ii) {
+ for (unordered_map<VK_IMAGE_VIEW, IMAGE_NODE*>::iterator ii=imageMap.begin(); ii!=imageMap.end(); ++ii) {
delete (*ii).second;
}
}
-static XGL_BUFFER_VIEW_CREATE_INFO* getBufferViewCreateInfo(XGL_BUFFER_VIEW view)
+static VK_BUFFER_VIEW_CREATE_INFO* getBufferViewCreateInfo(VK_BUFFER_VIEW view)
{
loader_platform_thread_lock_mutex(&globalLock);
if (bufferMap.find(view) == bufferMap.end()) {
@@ -282,13 +282,13 @@
// Free all buffer nodes
static void freeBuffers()
{
- for (unordered_map<XGL_BUFFER_VIEW, BUFFER_NODE*>::iterator ii=bufferMap.begin(); ii!=bufferMap.end(); ++ii) {
+ for (unordered_map<VK_BUFFER_VIEW, BUFFER_NODE*>::iterator ii=bufferMap.begin(); ii!=bufferMap.end(); ++ii) {
delete (*ii).second;
}
}
-static GLOBAL_CB_NODE* getCBNode(XGL_CMD_BUFFER cb);
+static GLOBAL_CB_NODE* getCBNode(VK_CMD_BUFFER cb);
-static void updateCBTracking(XGL_CMD_BUFFER cb)
+static void updateCBTracking(VK_CMD_BUFFER cb)
{
g_lastCmdBuffer[getTIDIndex()] = cb;
GLOBAL_CB_NODE* pCB = getCBNode(cb);
@@ -307,22 +307,22 @@
}
// Print the last bound dynamic state
-static void printDynamicState(const XGL_CMD_BUFFER cb)
+static void printDynamicState(const VK_CMD_BUFFER cb)
{
GLOBAL_CB_NODE* pCB = getCBNode(cb);
if (pCB) {
loader_platform_thread_lock_mutex(&globalLock);
char str[4*1024];
- for (uint32_t i = 0; i < XGL_NUM_STATE_BIND_POINT; i++) {
+ for (uint32_t i = 0; i < VK_NUM_STATE_BIND_POINT; i++) {
if (pCB->lastBoundDynamicState[i]) {
- sprintf(str, "Reporting CreateInfo for currently bound %s object %p", string_XGL_STATE_BIND_POINT((XGL_STATE_BIND_POINT)i), pCB->lastBoundDynamicState[i]->stateObj);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pCB->lastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", str);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pCB->lastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", dynamic_display(pCB->lastBoundDynamicState[i]->pCreateInfo, " ").c_str());
+ sprintf(str, "Reporting CreateInfo for currently bound %s object %p", string_VK_STATE_BIND_POINT((VK_STATE_BIND_POINT)i), pCB->lastBoundDynamicState[i]->stateObj);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pCB->lastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pCB->lastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", dynamic_display(pCB->lastBoundDynamicState[i]->pCreateInfo, " ").c_str());
break;
}
else {
- sprintf(str, "No dynamic state of type %s bound", string_XGL_STATE_BIND_POINT((XGL_STATE_BIND_POINT)i));
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", str);
+ sprintf(str, "No dynamic state of type %s bound", string_VK_STATE_BIND_POINT((VK_STATE_BIND_POINT)i));
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", str);
}
}
loader_platform_thread_unlock_mutex(&globalLock);
@@ -330,11 +330,11 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cb);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cb, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
}
// Retrieve pipeline node ptr for given pipeline object
-static PIPELINE_NODE* getPipeline(XGL_PIPELINE pipeline)
+static PIPELINE_NODE* getPipeline(VK_PIPELINE pipeline)
{
loader_platform_thread_lock_mutex(&globalLock);
if (pipelineMap.find(pipeline) == pipelineMap.end()) {
@@ -346,7 +346,7 @@
}
// For given sampler, return a ptr to its Create Info struct, or NULL if sampler not found
-static XGL_SAMPLER_CREATE_INFO* getSamplerCreateInfo(const XGL_SAMPLER sampler)
+static VK_SAMPLER_CREATE_INFO* getSamplerCreateInfo(const VK_SAMPLER sampler)
{
loader_platform_thread_lock_mutex(&globalLock);
if (sampleMap.find(sampler) == sampleMap.end()) {
@@ -359,116 +359,116 @@
// Init the pipeline mapping info based on pipeline create info LL tree
// Threading note : Calls to this function should wrapped in mutex
-static void initPipeline(PIPELINE_NODE* pPipeline, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo)
+static void initPipeline(PIPELINE_NODE* pPipeline, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo)
{
// First init create info, we'll shadow the structs as we go down the tree
// TODO : Validate that no create info is incorrectly replicated
- memcpy(&pPipeline->graphicsPipelineCI, pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO));
+ memcpy(&pPipeline->graphicsPipelineCI, pCreateInfo, sizeof(VK_GRAPHICS_PIPELINE_CREATE_INFO));
GENERIC_HEADER* pTrav = (GENERIC_HEADER*)pCreateInfo->pNext;
GENERIC_HEADER* pPrev = (GENERIC_HEADER*)&pPipeline->graphicsPipelineCI; // Hold prev ptr to tie chain of structs together
size_t bufferSize = 0;
- XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pVICI = NULL;
- XGL_PIPELINE_CB_STATE_CREATE_INFO* pCBCI = NULL;
- XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pTmpPSSCI = NULL;
+ VK_PIPELINE_VERTEX_INPUT_CREATE_INFO* pVICI = NULL;
+ VK_PIPELINE_CB_STATE_CREATE_INFO* pCBCI = NULL;
+ VK_PIPELINE_SHADER_STAGE_CREATE_INFO* pTmpPSSCI = NULL;
while (pTrav) {
switch (pTrav->sType) {
- case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
- pTmpPSSCI = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pTrav;
+ case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+ pTmpPSSCI = (VK_PIPELINE_SHADER_STAGE_CREATE_INFO*)pTrav;
switch (pTmpPSSCI->shader.stage) {
- case XGL_SHADER_STAGE_VERTEX:
+ case VK_SHADER_STAGE_VERTEX:
pPrev->pNext = &pPipeline->vsCI;
pPrev = (GENERIC_HEADER*)&pPipeline->vsCI;
- memcpy(&pPipeline->vsCI, pTmpPSSCI, sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO));
+ memcpy(&pPipeline->vsCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO));
break;
- case XGL_SHADER_STAGE_TESS_CONTROL:
+ case VK_SHADER_STAGE_TESS_CONTROL:
pPrev->pNext = &pPipeline->tcsCI;
pPrev = (GENERIC_HEADER*)&pPipeline->tcsCI;
- memcpy(&pPipeline->tcsCI, pTmpPSSCI, sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO));
+ memcpy(&pPipeline->tcsCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO));
break;
- case XGL_SHADER_STAGE_TESS_EVALUATION:
+ case VK_SHADER_STAGE_TESS_EVALUATION:
pPrev->pNext = &pPipeline->tesCI;
pPrev = (GENERIC_HEADER*)&pPipeline->tesCI;
- memcpy(&pPipeline->tesCI, pTmpPSSCI, sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO));
+ memcpy(&pPipeline->tesCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO));
break;
- case XGL_SHADER_STAGE_GEOMETRY:
+ case VK_SHADER_STAGE_GEOMETRY:
pPrev->pNext = &pPipeline->gsCI;
pPrev = (GENERIC_HEADER*)&pPipeline->gsCI;
- memcpy(&pPipeline->gsCI, pTmpPSSCI, sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO));
+ memcpy(&pPipeline->gsCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO));
break;
- case XGL_SHADER_STAGE_FRAGMENT:
+ case VK_SHADER_STAGE_FRAGMENT:
pPrev->pNext = &pPipeline->fsCI;
pPrev = (GENERIC_HEADER*)&pPipeline->fsCI;
- memcpy(&pPipeline->fsCI, pTmpPSSCI, sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO));
+ memcpy(&pPipeline->fsCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO));
break;
- case XGL_SHADER_STAGE_COMPUTE:
- // TODO : Flag error, CS is specified through XGL_COMPUTE_PIPELINE_CREATE_INFO
+ case VK_SHADER_STAGE_COMPUTE:
+ // TODO : Flag error, CS is specified through VK_COMPUTE_PIPELINE_CREATE_INFO
break;
default:
// TODO : Flag error
break;
}
break;
- case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
pPrev->pNext = &pPipeline->vertexInputCI;
pPrev = (GENERIC_HEADER*)&pPipeline->vertexInputCI;
- memcpy((void*)&pPipeline->vertexInputCI, pTrav, sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO));
+ memcpy((void*)&pPipeline->vertexInputCI, pTrav, sizeof(VK_PIPELINE_VERTEX_INPUT_CREATE_INFO));
// Copy embedded ptrs
- pVICI = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav;
+ pVICI = (VK_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav;
pPipeline->vtxBindingCount = pVICI->bindingCount;
if (pPipeline->vtxBindingCount) {
- pPipeline->pVertexBindingDescriptions = new XGL_VERTEX_INPUT_BINDING_DESCRIPTION[pPipeline->vtxBindingCount];
- bufferSize = pPipeline->vtxBindingCount * sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION);
- memcpy((void*)pPipeline->pVertexBindingDescriptions, ((XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav)->pVertexAttributeDescriptions, bufferSize);
+ pPipeline->pVertexBindingDescriptions = new VK_VERTEX_INPUT_BINDING_DESCRIPTION[pPipeline->vtxBindingCount];
+ bufferSize = pPipeline->vtxBindingCount * sizeof(VK_VERTEX_INPUT_BINDING_DESCRIPTION);
+ memcpy((void*)pPipeline->pVertexBindingDescriptions, ((VK_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav)->pVertexAttributeDescriptions, bufferSize);
}
pPipeline->vtxAttributeCount = pVICI->attributeCount;
if (pPipeline->vtxAttributeCount) {
- pPipeline->pVertexAttributeDescriptions = new XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION[pPipeline->vtxAttributeCount];
- bufferSize = pPipeline->vtxAttributeCount * sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION);
- memcpy((void*)pPipeline->pVertexAttributeDescriptions, ((XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav)->pVertexAttributeDescriptions, bufferSize);
+ pPipeline->pVertexAttributeDescriptions = new VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION[pPipeline->vtxAttributeCount];
+ bufferSize = pPipeline->vtxAttributeCount * sizeof(VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION);
+ memcpy((void*)pPipeline->pVertexAttributeDescriptions, ((VK_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav)->pVertexAttributeDescriptions, bufferSize);
}
break;
- case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+ case VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
pPrev->pNext = &pPipeline->iaStateCI;
pPrev = (GENERIC_HEADER*)&pPipeline->iaStateCI;
- memcpy((void*)&pPipeline->iaStateCI, pTrav, sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO));
+ memcpy((void*)&pPipeline->iaStateCI, pTrav, sizeof(VK_PIPELINE_IA_STATE_CREATE_INFO));
break;
- case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+ case VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
pPrev->pNext = &pPipeline->tessStateCI;
pPrev = (GENERIC_HEADER*)&pPipeline->tessStateCI;
- memcpy((void*)&pPipeline->tessStateCI, pTrav, sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO));
+ memcpy((void*)&pPipeline->tessStateCI, pTrav, sizeof(VK_PIPELINE_TESS_STATE_CREATE_INFO));
break;
- case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
+ case VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
pPrev->pNext = &pPipeline->vpStateCI;
pPrev = (GENERIC_HEADER*)&pPipeline->vpStateCI;
- memcpy((void*)&pPipeline->vpStateCI, pTrav, sizeof(XGL_PIPELINE_VP_STATE_CREATE_INFO));
+ memcpy((void*)&pPipeline->vpStateCI, pTrav, sizeof(VK_PIPELINE_VP_STATE_CREATE_INFO));
break;
- case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+ case VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
pPrev->pNext = &pPipeline->rsStateCI;
pPrev = (GENERIC_HEADER*)&pPipeline->rsStateCI;
- memcpy((void*)&pPipeline->rsStateCI, pTrav, sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO));
+ memcpy((void*)&pPipeline->rsStateCI, pTrav, sizeof(VK_PIPELINE_RS_STATE_CREATE_INFO));
break;
- case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
+ case VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
pPrev->pNext = &pPipeline->msStateCI;
pPrev = (GENERIC_HEADER*)&pPipeline->msStateCI;
- memcpy((void*)&pPipeline->msStateCI, pTrav, sizeof(XGL_PIPELINE_MS_STATE_CREATE_INFO));
+ memcpy((void*)&pPipeline->msStateCI, pTrav, sizeof(VK_PIPELINE_MS_STATE_CREATE_INFO));
break;
- case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+ case VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
pPrev->pNext = &pPipeline->cbStateCI;
pPrev = (GENERIC_HEADER*)&pPipeline->cbStateCI;
- memcpy((void*)&pPipeline->cbStateCI, pTrav, sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO));
+ memcpy((void*)&pPipeline->cbStateCI, pTrav, sizeof(VK_PIPELINE_CB_STATE_CREATE_INFO));
// Copy embedded ptrs
- pCBCI = (XGL_PIPELINE_CB_STATE_CREATE_INFO*)pTrav;
+ pCBCI = (VK_PIPELINE_CB_STATE_CREATE_INFO*)pTrav;
pPipeline->attachmentCount = pCBCI->attachmentCount;
if (pPipeline->attachmentCount) {
- pPipeline->pAttachments = new XGL_PIPELINE_CB_ATTACHMENT_STATE[pPipeline->attachmentCount];
- bufferSize = pPipeline->attachmentCount * sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE);
- memcpy((void*)pPipeline->pAttachments, ((XGL_PIPELINE_CB_STATE_CREATE_INFO*)pTrav)->pAttachments, bufferSize);
+ pPipeline->pAttachments = new VK_PIPELINE_CB_ATTACHMENT_STATE[pPipeline->attachmentCount];
+ bufferSize = pPipeline->attachmentCount * sizeof(VK_PIPELINE_CB_ATTACHMENT_STATE);
+ memcpy((void*)pPipeline->pAttachments, ((VK_PIPELINE_CB_STATE_CREATE_INFO*)pTrav)->pAttachments, bufferSize);
}
break;
- case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
+ case VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
pPrev->pNext = &pPipeline->dsStateCI;
pPrev = (GENERIC_HEADER*)&pPipeline->dsStateCI;
- memcpy((void*)&pPipeline->dsStateCI, pTrav, sizeof(XGL_PIPELINE_DS_STATE_CREATE_INFO));
+ memcpy((void*)&pPipeline->dsStateCI, pTrav, sizeof(VK_PIPELINE_DS_STATE_CREATE_INFO));
break;
default:
assert(0);
@@ -481,7 +481,7 @@
// Free the Pipeline nodes
static void freePipelines()
{
- for (unordered_map<XGL_PIPELINE, PIPELINE_NODE*>::iterator ii=pipelineMap.begin(); ii!=pipelineMap.end(); ++ii) {
+ for (unordered_map<VK_PIPELINE, PIPELINE_NODE*>::iterator ii=pipelineMap.begin(); ii!=pipelineMap.end(); ++ii) {
if ((*ii).second->pVertexBindingDescriptions) {
delete[] (*ii).second->pVertexBindingDescriptions;
}
@@ -495,28 +495,28 @@
}
}
// For given pipeline, return number of MSAA samples, or one if MSAA disabled
-static uint32_t getNumSamples(const XGL_PIPELINE pipeline)
+static uint32_t getNumSamples(const VK_PIPELINE pipeline)
{
PIPELINE_NODE* pPipe = pipelineMap[pipeline];
- if (XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO == pPipe->msStateCI.sType) {
+ if (VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO == pPipe->msStateCI.sType) {
if (pPipe->msStateCI.multisampleEnable)
return pPipe->msStateCI.samples;
}
return 1;
}
// Validate state related to the PSO
-static void validatePipelineState(const GLOBAL_CB_NODE* pCB, const XGL_PIPELINE_BIND_POINT pipelineBindPoint, const XGL_PIPELINE pipeline)
+static void validatePipelineState(const GLOBAL_CB_NODE* pCB, const VK_PIPELINE_BIND_POINT pipelineBindPoint, const VK_PIPELINE pipeline)
{
- if (XGL_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) {
+ if (VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) {
// Verify that any MSAA request in PSO matches sample# in bound FB
uint32_t psoNumSamples = getNumSamples(pipeline);
if (pCB->activeRenderPass) {
- XGL_RENDER_PASS_CREATE_INFO* pRPCI = renderPassMap[pCB->activeRenderPass];
- XGL_FRAMEBUFFER_CREATE_INFO* pFBCI = frameBufferMap[pCB->framebuffer];
+ VK_RENDER_PASS_CREATE_INFO* pRPCI = renderPassMap[pCB->activeRenderPass];
+ VK_FRAMEBUFFER_CREATE_INFO* pFBCI = frameBufferMap[pCB->framebuffer];
if (psoNumSamples != pFBCI->sampleCount) {
char str[1024];
sprintf(str, "Num samples mismatche! Binding PSO (%p) with %u samples while current RenderPass (%p) uses FB (%p) with %u samples!", (void*)pipeline, psoNumSamples, (void*)pCB->activeRenderPass, (void*)pCB->framebuffer, pFBCI->sampleCount);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pipeline, 0, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pipeline, 0, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS", str);
}
} else {
// TODO : I believe it's an error if we reach this point and don't have an activeRenderPass
@@ -531,7 +531,7 @@
// Block of code at start here specifically for managing/tracking DSs
// Return Pool node ptr for specified pool or else NULL
-static POOL_NODE* getPoolNode(XGL_DESCRIPTOR_POOL pool)
+static POOL_NODE* getPoolNode(VK_DESCRIPTOR_POOL pool)
{
loader_platform_thread_lock_mutex(&globalLock);
if (poolMap.find(pool) == poolMap.end()) {
@@ -542,7 +542,7 @@
return poolMap[pool];
}
// Return Set node ptr for specified set or else NULL
-static SET_NODE* getSetNode(XGL_DESCRIPTOR_SET set)
+static SET_NODE* getSetNode(VK_DESCRIPTOR_SET set)
{
loader_platform_thread_lock_mutex(&globalLock);
if (setMap.find(set) == setMap.end()) {
@@ -553,8 +553,8 @@
return setMap[set];
}
-// Return XGL_TRUE if DS Exists and is within an xglBeginDescriptorPoolUpdate() call sequence, otherwise XGL_FALSE
-static bool32_t dsUpdateActive(XGL_DESCRIPTOR_SET ds)
+// Return VK_TRUE if DS Exists and is within an vkBeginDescriptorPoolUpdate() call sequence, otherwise VK_FALSE
+static bool32_t dsUpdateActive(VK_DESCRIPTOR_SET ds)
{
// Note, both "get" functions use global mutex so this guy does not
SET_NODE* pTrav = getSetNode(ds);
@@ -564,10 +564,10 @@
return pPool->updateActive;
}
}
- return XGL_FALSE;
+ return VK_FALSE;
}
-static LAYOUT_NODE* getLayoutNode(const XGL_DESCRIPTOR_SET_LAYOUT layout) {
+static LAYOUT_NODE* getLayoutNode(const VK_DESCRIPTOR_SET_LAYOUT layout) {
loader_platform_thread_lock_mutex(&globalLock);
if (layoutMap.find(layout) == layoutMap.end()) {
loader_platform_thread_unlock_mutex(&globalLock);
@@ -582,16 +582,16 @@
{
switch (pUpdateStruct->sType)
{
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
- return ((XGL_UPDATE_SAMPLERS*)pUpdateStruct)->binding;
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
- return ((XGL_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->binding;
- case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
- return ((XGL_UPDATE_IMAGES*)pUpdateStruct)->binding;
- case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
- return ((XGL_UPDATE_BUFFERS*)pUpdateStruct)->binding;
- case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
- return ((XGL_UPDATE_AS_COPY*)pUpdateStruct)->binding;
+ case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ return ((VK_UPDATE_SAMPLERS*)pUpdateStruct)->binding;
+ case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ return ((VK_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->binding;
+ case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
+ return ((VK_UPDATE_IMAGES*)pUpdateStruct)->binding;
+ case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ return ((VK_UPDATE_BUFFERS*)pUpdateStruct)->binding;
+ case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ return ((VK_UPDATE_AS_COPY*)pUpdateStruct)->binding;
default:
// TODO : Flag specific error for this case
assert(0);
@@ -603,17 +603,17 @@
{
switch (pUpdateStruct->sType)
{
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
- return (((XGL_UPDATE_SAMPLERS*)pUpdateStruct)->arrayIndex);
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
- return (((XGL_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->arrayIndex);
- case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
- return (((XGL_UPDATE_IMAGES*)pUpdateStruct)->arrayIndex);
- case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
- return (((XGL_UPDATE_BUFFERS*)pUpdateStruct)->arrayIndex);
- case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ return (((VK_UPDATE_SAMPLERS*)pUpdateStruct)->arrayIndex);
+ case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ return (((VK_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->arrayIndex);
+ case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
+ return (((VK_UPDATE_IMAGES*)pUpdateStruct)->arrayIndex);
+ case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ return (((VK_UPDATE_BUFFERS*)pUpdateStruct)->arrayIndex);
+ case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
// TODO : Need to understand this case better and make sure code is correct
- return (((XGL_UPDATE_AS_COPY*)pUpdateStruct)->arrayElement);
+ return (((VK_UPDATE_AS_COPY*)pUpdateStruct)->arrayElement);
default:
// TODO : Flag specific error for this case
assert(0);
@@ -625,17 +625,17 @@
{
switch (pUpdateStruct->sType)
{
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
- return (((XGL_UPDATE_SAMPLERS*)pUpdateStruct)->count);
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
- return (((XGL_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->count);
- case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
- return (((XGL_UPDATE_IMAGES*)pUpdateStruct)->count);
- case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
- return (((XGL_UPDATE_BUFFERS*)pUpdateStruct)->count);
- case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ return (((VK_UPDATE_SAMPLERS*)pUpdateStruct)->count);
+ case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ return (((VK_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->count);
+ case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
+ return (((VK_UPDATE_IMAGES*)pUpdateStruct)->count);
+ case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ return (((VK_UPDATE_BUFFERS*)pUpdateStruct)->count);
+ case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
// TODO : Need to understand this case better and make sure code is correct
- return (((XGL_UPDATE_AS_COPY*)pUpdateStruct)->count);
+ return (((VK_UPDATE_AS_COPY*)pUpdateStruct)->count);
default:
// TODO : Flag specific error for this case
assert(0);
@@ -674,24 +674,24 @@
static bool32_t validateUpdateType(const LAYOUT_NODE* pLayout, const GENERIC_HEADER* pUpdateStruct)
{
// First get actual type of update
- XGL_DESCRIPTOR_TYPE actualType;
+ VK_DESCRIPTOR_TYPE actualType;
uint32_t i = 0;
switch (pUpdateStruct->sType)
{
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
- actualType = XGL_DESCRIPTOR_TYPE_SAMPLER;
+ case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ actualType = VK_DESCRIPTOR_TYPE_SAMPLER;
break;
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
- actualType = XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE;
+ case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ actualType = VK_DESCRIPTOR_TYPE_SAMPLER_TEXTURE;
break;
- case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
- actualType = ((XGL_UPDATE_IMAGES*)pUpdateStruct)->descriptorType;
+ case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
+ actualType = ((VK_UPDATE_IMAGES*)pUpdateStruct)->descriptorType;
break;
- case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
- actualType = ((XGL_UPDATE_BUFFERS*)pUpdateStruct)->descriptorType;
+ case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ actualType = ((VK_UPDATE_BUFFERS*)pUpdateStruct)->descriptorType;
break;
- case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
- actualType = ((XGL_UPDATE_AS_COPY*)pUpdateStruct)->descriptorType;
+ case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ actualType = ((VK_UPDATE_AS_COPY*)pUpdateStruct)->descriptorType;
break;
default:
// TODO : Flag specific error for this case
@@ -713,86 +713,86 @@
size_t base_array_size = 0;
size_t total_array_size = 0;
size_t baseBuffAddr = 0;
- XGL_UPDATE_BUFFERS* pUBCI;
- XGL_UPDATE_IMAGES* pUICI;
- XGL_IMAGE_VIEW_ATTACH_INFO** ppLocalImageViews = NULL;
- XGL_BUFFER_VIEW_ATTACH_INFO** ppLocalBufferViews = NULL;
+ VK_UPDATE_BUFFERS* pUBCI;
+ VK_UPDATE_IMAGES* pUICI;
+ VK_IMAGE_VIEW_ATTACH_INFO** ppLocalImageViews = NULL;
+ VK_BUFFER_VIEW_ATTACH_INFO** ppLocalBufferViews = NULL;
char str[1024];
switch (pUpdate->sType)
{
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
- pNewNode = (GENERIC_HEADER*)malloc(sizeof(XGL_UPDATE_SAMPLERS));
+ case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ pNewNode = (GENERIC_HEADER*)malloc(sizeof(VK_UPDATE_SAMPLERS));
#if ALLOC_DEBUG
printf("Alloc10 #%lu pNewNode addr(%p)\n", ++g_alloc_count, (void*)pNewNode);
#endif
- memcpy(pNewNode, pUpdate, sizeof(XGL_UPDATE_SAMPLERS));
- array_size = sizeof(XGL_SAMPLER) * ((XGL_UPDATE_SAMPLERS*)pNewNode)->count;
- ((XGL_UPDATE_SAMPLERS*)pNewNode)->pSamplers = (XGL_SAMPLER*)malloc(array_size);
+ memcpy(pNewNode, pUpdate, sizeof(VK_UPDATE_SAMPLERS));
+ array_size = sizeof(VK_SAMPLER) * ((VK_UPDATE_SAMPLERS*)pNewNode)->count;
+ ((VK_UPDATE_SAMPLERS*)pNewNode)->pSamplers = (VK_SAMPLER*)malloc(array_size);
#if ALLOC_DEBUG
- printf("Alloc11 #%lu pNewNode->pSamplers addr(%p)\n", ++g_alloc_count, (void*)((XGL_UPDATE_SAMPLERS*)pNewNode)->pSamplers);
+ printf("Alloc11 #%lu pNewNode->pSamplers addr(%p)\n", ++g_alloc_count, (void*)((VK_UPDATE_SAMPLERS*)pNewNode)->pSamplers);
#endif
- memcpy((XGL_SAMPLER*)((XGL_UPDATE_SAMPLERS*)pNewNode)->pSamplers, ((XGL_UPDATE_SAMPLERS*)pUpdate)->pSamplers, array_size);
+ memcpy((VK_SAMPLER*)((VK_UPDATE_SAMPLERS*)pNewNode)->pSamplers, ((VK_UPDATE_SAMPLERS*)pUpdate)->pSamplers, array_size);
break;
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
- pNewNode = (GENERIC_HEADER*)malloc(sizeof(XGL_UPDATE_SAMPLER_TEXTURES));
+ case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ pNewNode = (GENERIC_HEADER*)malloc(sizeof(VK_UPDATE_SAMPLER_TEXTURES));
#if ALLOC_DEBUG
printf("Alloc12 #%lu pNewNode addr(%p)\n", ++g_alloc_count, (void*)pNewNode);
#endif
- memcpy(pNewNode, pUpdate, sizeof(XGL_UPDATE_SAMPLER_TEXTURES));
- array_size = sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO) * ((XGL_UPDATE_SAMPLER_TEXTURES*)pNewNode)->count;
- ((XGL_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews = (XGL_SAMPLER_IMAGE_VIEW_INFO*)malloc(array_size);
+ memcpy(pNewNode, pUpdate, sizeof(VK_UPDATE_SAMPLER_TEXTURES));
+ array_size = sizeof(VK_SAMPLER_IMAGE_VIEW_INFO) * ((VK_UPDATE_SAMPLER_TEXTURES*)pNewNode)->count;
+ ((VK_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews = (VK_SAMPLER_IMAGE_VIEW_INFO*)malloc(array_size);
#if ALLOC_DEBUG
- printf("Alloc13 #%lu pNewNode->pSamplerImageViews addr(%p)\n", ++g_alloc_count, (void*)((XGL_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews);
+ printf("Alloc13 #%lu pNewNode->pSamplerImageViews addr(%p)\n", ++g_alloc_count, (void*)((VK_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews);
#endif
- for (uint32_t i = 0; i < ((XGL_UPDATE_SAMPLER_TEXTURES*)pNewNode)->count; i++) {
- memcpy((XGL_SAMPLER_IMAGE_VIEW_INFO*)&((XGL_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews[i], &((XGL_UPDATE_SAMPLER_TEXTURES*)pUpdate)->pSamplerImageViews[i], sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO));
- ((XGL_SAMPLER_IMAGE_VIEW_INFO*)((XGL_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews)[i].pImageView = (XGL_IMAGE_VIEW_ATTACH_INFO*)malloc(sizeof(XGL_IMAGE_VIEW_ATTACH_INFO));
+ for (uint32_t i = 0; i < ((VK_UPDATE_SAMPLER_TEXTURES*)pNewNode)->count; i++) {
+ memcpy((VK_SAMPLER_IMAGE_VIEW_INFO*)&((VK_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews[i], &((VK_UPDATE_SAMPLER_TEXTURES*)pUpdate)->pSamplerImageViews[i], sizeof(VK_SAMPLER_IMAGE_VIEW_INFO));
+ ((VK_SAMPLER_IMAGE_VIEW_INFO*)((VK_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews)[i].pImageView = (VK_IMAGE_VIEW_ATTACH_INFO*)malloc(sizeof(VK_IMAGE_VIEW_ATTACH_INFO));
#if ALLOC_DEBUG
- printf("Alloc14 #%lu pSamplerImageViews)[%u].pImageView addr(%p)\n", ++g_alloc_count, i, (void*)((XGL_SAMPLER_IMAGE_VIEW_INFO*)((XGL_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews)[i].pImageView);
+ printf("Alloc14 #%lu pSamplerImageViews)[%u].pImageView addr(%p)\n", ++g_alloc_count, i, (void*)((VK_SAMPLER_IMAGE_VIEW_INFO*)((VK_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews)[i].pImageView);
#endif
- memcpy((XGL_IMAGE_VIEW_ATTACH_INFO*)((XGL_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews[i].pImageView, ((XGL_UPDATE_SAMPLER_TEXTURES*)pUpdate)->pSamplerImageViews[i].pImageView, sizeof(XGL_IMAGE_VIEW_ATTACH_INFO));
+ memcpy((VK_IMAGE_VIEW_ATTACH_INFO*)((VK_UPDATE_SAMPLER_TEXTURES*)pNewNode)->pSamplerImageViews[i].pImageView, ((VK_UPDATE_SAMPLER_TEXTURES*)pUpdate)->pSamplerImageViews[i].pImageView, sizeof(VK_IMAGE_VIEW_ATTACH_INFO));
}
break;
- case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
- pUICI = (XGL_UPDATE_IMAGES*)pUpdate;
- pNewNode = (GENERIC_HEADER*)malloc(sizeof(XGL_UPDATE_IMAGES));
+ case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
+ pUICI = (VK_UPDATE_IMAGES*)pUpdate;
+ pNewNode = (GENERIC_HEADER*)malloc(sizeof(VK_UPDATE_IMAGES));
#if ALLOC_DEBUG
printf("Alloc15 #%lu pNewNode addr(%p)\n", ++g_alloc_count, (void*)pNewNode);
#endif
- memcpy(pNewNode, pUpdate, sizeof(XGL_UPDATE_IMAGES));
- total_array_size = (sizeof(XGL_IMAGE_VIEW_ATTACH_INFO) * ((XGL_UPDATE_IMAGES*)pNewNode)->count);
- ppLocalImageViews = (XGL_IMAGE_VIEW_ATTACH_INFO**)&(((XGL_UPDATE_IMAGES*)pNewNode)->pImageViews);
- *ppLocalImageViews = (XGL_IMAGE_VIEW_ATTACH_INFO*)malloc(total_array_size);
+ memcpy(pNewNode, pUpdate, sizeof(VK_UPDATE_IMAGES));
+ total_array_size = (sizeof(VK_IMAGE_VIEW_ATTACH_INFO) * ((VK_UPDATE_IMAGES*)pNewNode)->count);
+ ppLocalImageViews = (VK_IMAGE_VIEW_ATTACH_INFO**)&(((VK_UPDATE_IMAGES*)pNewNode)->pImageViews);
+ *ppLocalImageViews = (VK_IMAGE_VIEW_ATTACH_INFO*)malloc(total_array_size);
#if ALLOC_DEBUG
printf("Alloc16 #%lu *pppLocalImageViews addr(%p)\n", ++g_alloc_count, (void*)*ppLocalImageViews);
#endif
memcpy((void*)*ppLocalImageViews, pUICI->pImageViews, total_array_size);
break;
- case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
- pUBCI = (XGL_UPDATE_BUFFERS*)pUpdate;
- pNewNode = (GENERIC_HEADER*)malloc(sizeof(XGL_UPDATE_BUFFERS));
+ case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ pUBCI = (VK_UPDATE_BUFFERS*)pUpdate;
+ pNewNode = (GENERIC_HEADER*)malloc(sizeof(VK_UPDATE_BUFFERS));
#if ALLOC_DEBUG
printf("Alloc17 #%lu pNewNode addr(%p)\n", ++g_alloc_count, (void*)pNewNode);
#endif
- memcpy(pNewNode, pUpdate, sizeof(XGL_UPDATE_BUFFERS));
- total_array_size = (sizeof(XGL_BUFFER_VIEW_ATTACH_INFO) * pUBCI->count);
- ppLocalBufferViews = (XGL_BUFFER_VIEW_ATTACH_INFO**)&(((XGL_UPDATE_BUFFERS*)pNewNode)->pBufferViews);
- *ppLocalBufferViews = (XGL_BUFFER_VIEW_ATTACH_INFO*)malloc(total_array_size);
+ memcpy(pNewNode, pUpdate, sizeof(VK_UPDATE_BUFFERS));
+ total_array_size = (sizeof(VK_BUFFER_VIEW_ATTACH_INFO) * pUBCI->count);
+ ppLocalBufferViews = (VK_BUFFER_VIEW_ATTACH_INFO**)&(((VK_UPDATE_BUFFERS*)pNewNode)->pBufferViews);
+ *ppLocalBufferViews = (VK_BUFFER_VIEW_ATTACH_INFO*)malloc(total_array_size);
#if ALLOC_DEBUG
printf("Alloc18 #%lu *pppLocalBufferViews addr(%p)\n", ++g_alloc_count, (void*)*ppLocalBufferViews);
#endif
memcpy((void*)*ppLocalBufferViews, pUBCI->pBufferViews, total_array_size);
break;
- case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
- pNewNode = (GENERIC_HEADER*)malloc(sizeof(XGL_UPDATE_AS_COPY));
+ case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ pNewNode = (GENERIC_HEADER*)malloc(sizeof(VK_UPDATE_AS_COPY));
#if ALLOC_DEBUG
printf("Alloc19 #%lu pNewNode addr(%p)\n", ++g_alloc_count, (void*)pNewNode);
#endif
- memcpy(pNewNode, pUpdate, sizeof(XGL_UPDATE_AS_COPY));
+ memcpy(pNewNode, pUpdate, sizeof(VK_UPDATE_AS_COPY));
break;
default:
- sprintf(str, "Unexpected UPDATE struct of type %s (value %u) in xglUpdateDescriptors() struct tree", string_XGL_STRUCTURE_TYPE(pUpdate->sType), pUpdate->sType);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", str);
+ sprintf(str, "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VK_STRUCTURE_TYPE(pUpdate->sType), pUpdate->sType);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", str);
return NULL;
}
// Make sure that pNext for the end of shadow copy is NULL
@@ -800,13 +800,13 @@
return pNewNode;
}
// For given ds, update its mapping based on ppUpdateArray
-static void dsUpdate(XGL_DESCRIPTOR_SET ds, uint32_t updateCount, const void** ppUpdateArray)
+static void dsUpdate(VK_DESCRIPTOR_SET ds, uint32_t updateCount, const void** ppUpdateArray)
{
SET_NODE* pSet = getSetNode(ds);
loader_platform_thread_lock_mutex(&globalLock);
g_lastBoundDescriptorSet = pSet->set;
LAYOUT_NODE* pLayout = NULL;
- XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pLayoutCI = NULL;
+ VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pLayoutCI = NULL;
// TODO : If pCIList is NULL, flag error
// Perform all updates
for (uint32_t i = 0; i < updateCount; i++) {
@@ -815,24 +815,24 @@
// Make sure that binding is within bounds
if (pLayout->createInfo.count < getUpdateBinding(pUpdate)) {
char str[1024];
- sprintf(str, "Descriptor Set %p does not have binding to match update binding %u for update type %s!", ds, getUpdateBinding(pUpdate), string_XGL_STRUCTURE_TYPE(pUpdate->sType));
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS", str);
+ sprintf(str, "Descriptor Set %p does not have binding to match update binding %u for update type %s!", ds, getUpdateBinding(pUpdate), string_VK_STRUCTURE_TYPE(pUpdate->sType));
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS", str);
}
else {
// Next verify that update falls within size of given binding
if (getBindingEndIndex(pLayout, getUpdateBinding(pUpdate)) < getUpdateEndIndex(pLayout, pUpdate)) {
char str[48*1024]; // TODO : Keep count of layout CI structs and size this string dynamically based on that count
pLayoutCI = &pLayout->createInfo;
- string DSstr = xgl_print_xgl_descriptor_set_layout_create_info(pLayoutCI, "{DS} ");
- sprintf(str, "Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_XGL_STRUCTURE_TYPE(pUpdate->sType), getUpdateBinding(pUpdate), DSstr.c_str());
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS", str);
+ string DSstr = vk_print_vk_descriptor_set_layout_create_info(pLayoutCI, "{DS} ");
+ sprintf(str, "Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_VK_STRUCTURE_TYPE(pUpdate->sType), getUpdateBinding(pUpdate), DSstr.c_str());
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS", str);
}
else { // TODO : should we skip update on a type mismatch or force it?
// Layout bindings match w/ update ok, now verify that update is of the right type
if (!validateUpdateType(pLayout, pUpdate)) {
char str[1024];
- sprintf(str, "Descriptor update type of %s does not match overlapping binding type!", string_XGL_STRUCTURE_TYPE(pUpdate->sType));
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, "DS", str);
+ sprintf(str, "Descriptor update type of %s does not match overlapping binding type!", string_VK_STRUCTURE_TYPE(pUpdate->sType));
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, "DS", str);
}
else {
// Save the update info
@@ -841,8 +841,8 @@
GENERIC_HEADER* pNewNode = shadowUpdateNode(pUpdate);
if (NULL == pNewNode) {
char str[1024];
- sprintf(str, "Out of memory while attempting to allocate UPDATE struct in xglUpdateDescriptors()");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
+ sprintf(str, "Out of memory while attempting to allocate UPDATE struct in vkUpdateDescriptors()");
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
}
else {
// Insert shadow node into LL of updates for this set
@@ -873,15 +873,15 @@
pFreeUpdate = pShadowUpdate;
pShadowUpdate = (GENERIC_HEADER*)pShadowUpdate->pNext;
uint32_t index = 0;
- XGL_UPDATE_SAMPLERS* pUS = NULL;
- XGL_UPDATE_SAMPLER_TEXTURES* pUST = NULL;
- XGL_UPDATE_IMAGES* pUI = NULL;
- XGL_UPDATE_BUFFERS* pUB = NULL;
+ VK_UPDATE_SAMPLERS* pUS = NULL;
+ VK_UPDATE_SAMPLER_TEXTURES* pUST = NULL;
+ VK_UPDATE_IMAGES* pUI = NULL;
+ VK_UPDATE_BUFFERS* pUB = NULL;
void** ppToFree = NULL;
switch (pFreeUpdate->sType)
{
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
- pUS = (XGL_UPDATE_SAMPLERS*)pFreeUpdate;
+ case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ pUS = (VK_UPDATE_SAMPLERS*)pFreeUpdate;
if (pUS->pSamplers) {
ppToFree = (void**)&pUS->pSamplers;
#if ALLOC_DEBUG
@@ -890,8 +890,8 @@
free(*ppToFree);
}
break;
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
- pUST = (XGL_UPDATE_SAMPLER_TEXTURES*)pFreeUpdate;
+ case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ pUST = (VK_UPDATE_SAMPLER_TEXTURES*)pFreeUpdate;
for (index = 0; index < pUST->count; index++) {
if (pUST->pSamplerImageViews[index].pImageView) {
ppToFree = (void**)&pUST->pSamplerImageViews[index].pImageView;
@@ -907,8 +907,8 @@
#endif
free(*ppToFree);
break;
- case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
- pUI = (XGL_UPDATE_IMAGES*)pFreeUpdate;
+ case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
+ pUI = (VK_UPDATE_IMAGES*)pFreeUpdate;
if (pUI->pImageViews) {
ppToFree = (void**)&pUI->pImageViews;
#if ALLOC_DEBUG
@@ -917,8 +917,8 @@
free(*ppToFree);
}
break;
- case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
- pUB = (XGL_UPDATE_BUFFERS*)pFreeUpdate;
+ case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ pUB = (VK_UPDATE_BUFFERS*)pFreeUpdate;
if (pUB->pBufferViews) {
ppToFree = (void**)&pUB->pBufferViews;
#if ALLOC_DEBUG
@@ -927,7 +927,7 @@
free(*ppToFree);
}
break;
- case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
break;
default:
assert(0);
@@ -943,7 +943,7 @@
// NOTE : Calls to this function should be wrapped in mutex
static void freePools()
{
- for (unordered_map<XGL_DESCRIPTOR_POOL, POOL_NODE*>::iterator ii=poolMap.begin(); ii!=poolMap.end(); ++ii) {
+ for (unordered_map<VK_DESCRIPTOR_POOL, POOL_NODE*>::iterator ii=poolMap.begin(); ii!=poolMap.end(); ++ii) {
SET_NODE* pSet = (*ii).second->pSets;
SET_NODE* pFreeSet = pSet;
while (pSet) {
@@ -967,7 +967,7 @@
// NOTE : Calls to this function should be wrapped in mutex
static void freeLayouts()
{
- for (unordered_map<XGL_DESCRIPTOR_SET_LAYOUT, LAYOUT_NODE*>::iterator ii=layoutMap.begin(); ii!=layoutMap.end(); ++ii) {
+ for (unordered_map<VK_DESCRIPTOR_SET_LAYOUT, LAYOUT_NODE*>::iterator ii=layoutMap.begin(); ii!=layoutMap.end(); ++ii) {
LAYOUT_NODE* pLayout = (*ii).second;
if (pLayout->pTypes) {
delete pLayout->pTypes;
@@ -977,7 +977,7 @@
}
// Currently clearing a set is removing all previous updates to that set
// TODO : Validate if this is correct clearing behavior
-static void clearDescriptorSet(XGL_DESCRIPTOR_SET set)
+static void clearDescriptorSet(VK_DESCRIPTOR_SET set)
{
SET_NODE* pSet = getSetNode(set);
if (!pSet) {
@@ -990,13 +990,13 @@
}
}
-static void clearDescriptorPool(XGL_DESCRIPTOR_POOL pool)
+static void clearDescriptorPool(VK_DESCRIPTOR_POOL pool)
{
POOL_NODE* pPool = getPoolNode(pool);
if (!pPool) {
char str[1024];
- sprintf(str, "Unable to find pool node for pool %p specified in xglClearDescriptorPool() call", (void*)pool);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pool, 0, DRAWSTATE_INVALID_POOL, "DS", str);
+ sprintf(str, "Unable to find pool node for pool %p specified in vkClearDescriptorPool() call", (void*)pool);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pool, 0, DRAWSTATE_INVALID_POOL, "DS", str);
}
else
{
@@ -1008,7 +1008,7 @@
}
}
// Code here to manage the Cmd buffer LL
-static GLOBAL_CB_NODE* getCBNode(XGL_CMD_BUFFER cb)
+static GLOBAL_CB_NODE* getCBNode(VK_CMD_BUFFER cb)
{
loader_platform_thread_lock_mutex(&globalLock);
if (cmdBufferMap.find(cb) == cmdBufferMap.end()) {
@@ -1022,7 +1022,7 @@
// NOTE : Calls to this function should be wrapped in mutex
static void freeCmdBuffers()
{
- for (unordered_map<XGL_CMD_BUFFER, GLOBAL_CB_NODE*>::iterator ii=cmdBufferMap.begin(); ii!=cmdBufferMap.end(); ++ii) {
+ for (unordered_map<VK_CMD_BUFFER, GLOBAL_CB_NODE*>::iterator ii=cmdBufferMap.begin(); ii!=cmdBufferMap.end(); ++ii) {
while (!(*ii).second->pCmds.empty()) {
delete (*ii).second->pCmds.back();
(*ii).second->pCmds.pop_back();
@@ -1043,10 +1043,10 @@
else {
char str[1024];
sprintf(str, "Out of memory while attempting to allocate new CMD_NODE for cmdBuffer %p", (void*)pCB->cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pCB->cmdBuffer, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pCB->cmdBuffer, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
}
}
-static void resetCB(const XGL_CMD_BUFFER cb)
+static void resetCB(const VK_CMD_BUFFER cb)
{
GLOBAL_CB_NODE* pCB = getCBNode(cb);
if (pCB) {
@@ -1055,7 +1055,7 @@
pCB->pCmds.pop_back();
}
// Reset CB state
- XGL_FLAGS saveFlags = pCB->flags;
+ VK_FLAGS saveFlags = pCB->flags;
uint32_t saveQueueNodeIndex = pCB->queueNodeIndex;
memset(pCB, 0, sizeof(GLOBAL_CB_NODE));
pCB->cmdBuffer = cb;
@@ -1066,7 +1066,7 @@
}
// Set the last bound dynamic state of given type
// TODO : Need to track this per cmdBuffer and correlate cmdBuffer for Draw w/ last bound for that cmdBuffer?
-static void setLastBoundDynamicState(const XGL_CMD_BUFFER cmdBuffer, const XGL_DYNAMIC_STATE_OBJECT state, const XGL_STATE_BIND_POINT sType)
+static void setLastBoundDynamicState(const VK_CMD_BUFFER cmdBuffer, const VK_DYNAMIC_STATE_OBJECT state, const VK_STATE_BIND_POINT sType)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -1076,7 +1076,7 @@
if (dynamicStateMap.find(state) == dynamicStateMap.end()) {
char str[1024];
sprintf(str, "Unable to find dynamic state object %p, was it ever created?", (void*)state);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, state, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, state, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", str);
}
else {
pCB->lastBoundDynamicState[sType] = dynamicStateMap[state];
@@ -1087,11 +1087,11 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
}
// Print the last bound Gfx Pipeline
-static void printPipeline(const XGL_CMD_BUFFER cb)
+static void printPipeline(const VK_CMD_BUFFER cb)
{
GLOBAL_CB_NODE* pCB = getCBNode(cb);
if (pCB) {
@@ -1100,13 +1100,13 @@
// nothing to print
}
else {
- string pipeStr = xgl_print_xgl_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "{DS}").c_str();
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", pipeStr.c_str());
+ string pipeStr = vk_print_vk_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "{DS}").c_str();
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", pipeStr.c_str());
}
}
}
// Common Dot dumping code
-static void dsCoreDumpDot(const XGL_DESCRIPTOR_SET ds, FILE* pOutFile)
+static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile)
{
SET_NODE* pSet = getSetNode(ds);
if (pSet) {
@@ -1114,7 +1114,7 @@
char tmp_str[4*1024];
fprintf(pOutFile, "subgraph cluster_DescriptorPool\n{\nlabel=\"Descriptor Pool\"\n");
sprintf(tmp_str, "Pool (%p)", pPool->pool);
- char* pGVstr = xgl_gv_print_xgl_descriptor_pool_create_info(&pPool->createInfo, tmp_str);
+ char* pGVstr = vk_gv_print_vk_descriptor_pool_create_info(&pPool->createInfo, tmp_str);
fprintf(pOutFile, "%s", pGVstr);
free(pGVstr);
fprintf(pOutFile, "subgraph cluster_DescriptorSet\n{\nlabel=\"Descriptor Set (%p)\"\n", pSet->set);
@@ -1123,7 +1123,7 @@
uint32_t layout_index = 0;
++layout_index;
sprintf(tmp_str, "LAYOUT%u", layout_index);
- pGVstr = xgl_gv_print_xgl_descriptor_set_layout_create_info(&pLayout->createInfo, tmp_str);
+ pGVstr = vk_gv_print_vk_descriptor_set_layout_create_info(&pLayout->createInfo, tmp_str);
fprintf(pOutFile, "%s", pGVstr);
free(pGVstr);
if (pSet->pUpdateStructs) {
@@ -1136,7 +1136,7 @@
uint32_t i = 0;
for (i=0; i < pSet->descriptorCount; i++) {
if (pSet->ppDescriptors[i]) {
- fprintf(pOutFile, "<TR><TD PORT=\"slot%u\">slot%u</TD><TD>%s</TD></TR>", i, i, string_XGL_STRUCTURE_TYPE(pSet->ppDescriptors[i]->sType));
+ fprintf(pOutFile, "<TR><TD PORT=\"slot%u\">slot%u</TD><TD>%s</TD></TR>", i, i, string_VK_STRUCTURE_TYPE(pSet->ppDescriptors[i]->sType));
}
}
#define NUM_COLORS 7
@@ -1151,71 +1151,71 @@
uint32_t colorIdx = 0;
fprintf(pOutFile, "</TABLE>>\n];\n");
// Now add the views that are mapped to active descriptors
- XGL_UPDATE_SAMPLERS* pUS = NULL;
- XGL_UPDATE_SAMPLER_TEXTURES* pUST = NULL;
- XGL_UPDATE_IMAGES* pUI = NULL;
- XGL_UPDATE_BUFFERS* pUB = NULL;
- XGL_UPDATE_AS_COPY* pUAC = NULL;
- XGL_SAMPLER_CREATE_INFO* pSCI = NULL;
- XGL_IMAGE_VIEW_CREATE_INFO* pIVCI = NULL;
- XGL_BUFFER_VIEW_CREATE_INFO* pBVCI = NULL;
+ VK_UPDATE_SAMPLERS* pUS = NULL;
+ VK_UPDATE_SAMPLER_TEXTURES* pUST = NULL;
+ VK_UPDATE_IMAGES* pUI = NULL;
+ VK_UPDATE_BUFFERS* pUB = NULL;
+ VK_UPDATE_AS_COPY* pUAC = NULL;
+ VK_SAMPLER_CREATE_INFO* pSCI = NULL;
+ VK_IMAGE_VIEW_CREATE_INFO* pIVCI = NULL;
+ VK_BUFFER_VIEW_CREATE_INFO* pBVCI = NULL;
void** ppNextPtr = NULL;
void* pSaveNext = NULL;
for (i=0; i < pSet->descriptorCount; i++) {
if (pSet->ppDescriptors[i]) {
switch (pSet->ppDescriptors[i]->sType)
{
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
- pUS = (XGL_UPDATE_SAMPLERS*)pSet->ppDescriptors[i];
+ case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ pUS = (VK_UPDATE_SAMPLERS*)pSet->ppDescriptors[i];
pSCI = getSamplerCreateInfo(pUS->pSamplers[i-pUS->arrayIndex]);
if (pSCI) {
sprintf(tmp_str, "SAMPLER%u", i);
- fprintf(pOutFile, "%s", xgl_gv_print_xgl_sampler_create_info(pSCI, tmp_str));
+ fprintf(pOutFile, "%s", vk_gv_print_vk_sampler_create_info(pSCI, tmp_str));
fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
}
break;
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
- pUST = (XGL_UPDATE_SAMPLER_TEXTURES*)pSet->ppDescriptors[i];
+ case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ pUST = (VK_UPDATE_SAMPLER_TEXTURES*)pSet->ppDescriptors[i];
pSCI = getSamplerCreateInfo(pUST->pSamplerImageViews[i-pUST->arrayIndex].sampler);
if (pSCI) {
sprintf(tmp_str, "SAMPLER%u", i);
- fprintf(pOutFile, "%s", xgl_gv_print_xgl_sampler_create_info(pSCI, tmp_str));
+ fprintf(pOutFile, "%s", vk_gv_print_vk_sampler_create_info(pSCI, tmp_str));
fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
}
pIVCI = getImageViewCreateInfo(pUST->pSamplerImageViews[i-pUST->arrayIndex].pImageView->view);
if (pIVCI) {
sprintf(tmp_str, "IMAGE_VIEW%u", i);
- fprintf(pOutFile, "%s", xgl_gv_print_xgl_image_view_create_info(pIVCI, tmp_str));
+ fprintf(pOutFile, "%s", vk_gv_print_vk_image_view_create_info(pIVCI, tmp_str));
fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
}
break;
- case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
- pUI = (XGL_UPDATE_IMAGES*)pSet->ppDescriptors[i];
+ case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
+ pUI = (VK_UPDATE_IMAGES*)pSet->ppDescriptors[i];
pIVCI = getImageViewCreateInfo(pUI->pImageViews[i-pUI->arrayIndex].view);
if (pIVCI) {
sprintf(tmp_str, "IMAGE_VIEW%u", i);
- fprintf(pOutFile, "%s", xgl_gv_print_xgl_image_view_create_info(pIVCI, tmp_str));
+ fprintf(pOutFile, "%s", vk_gv_print_vk_image_view_create_info(pIVCI, tmp_str));
fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
}
break;
- case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
- pUB = (XGL_UPDATE_BUFFERS*)pSet->ppDescriptors[i];
+ case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ pUB = (VK_UPDATE_BUFFERS*)pSet->ppDescriptors[i];
pBVCI = getBufferViewCreateInfo(pUB->pBufferViews[i-pUB->arrayIndex].view);
if (pBVCI) {
sprintf(tmp_str, "BUFFER_VIEW%u", i);
- fprintf(pOutFile, "%s", xgl_gv_print_xgl_buffer_view_create_info(pBVCI, tmp_str));
+ fprintf(pOutFile, "%s", vk_gv_print_vk_buffer_view_create_info(pBVCI, tmp_str));
fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
}
break;
- case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
- pUAC = (XGL_UPDATE_AS_COPY*)pSet->ppDescriptors[i];
+ case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ pUAC = (VK_UPDATE_AS_COPY*)pSet->ppDescriptors[i];
// TODO : Need to validate this code
// Save off pNext and set to NULL while printing this struct, then restore it
ppNextPtr = (void**)&pUAC->pNext;
pSaveNext = *ppNextPtr;
*ppNextPtr = NULL;
sprintf(tmp_str, "UPDATE_AS_COPY%u", i);
- fprintf(pOutFile, "%s", xgl_gv_print_xgl_update_as_copy(pUAC, tmp_str));
+ fprintf(pOutFile, "%s", vk_gv_print_vk_update_as_copy(pUAC, tmp_str));
fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
// Restore next ptr
*ppNextPtr = pSaveNext;
@@ -1232,7 +1232,7 @@
}
}
// Dump subgraph w/ DS info
-static void dsDumpDot(const XGL_CMD_BUFFER cb, FILE* pOutFile)
+static void dsDumpDot(const VK_CMD_BUFFER cb, FILE* pOutFile)
{
GLOBAL_CB_NODE* pCB = getCBNode(cb);
if (pCB && pCB->lastBoundDescriptorSet) {
@@ -1282,16 +1282,16 @@
fprintf(pOutFile, "digraph g {\ngraph [\nrankdir = \"TB\"\n];\nnode [\nfontsize = \"16\"\nshape = \"plaintext\"\n];\nedge [\n];\n");
fprintf(pOutFile, "subgraph cluster_dynamicState\n{\nlabel=\"Dynamic State\"\n");
char* pGVstr = NULL;
- for (uint32_t i = 0; i < XGL_NUM_STATE_BIND_POINT; i++) {
+ for (uint32_t i = 0; i < VK_NUM_STATE_BIND_POINT; i++) {
if (g_lastBoundDynamicState[i] && g_lastBoundDynamicState[i]->pCreateInfo) {
- pGVstr = dynamic_gv_display(g_lastBoundDynamicState[i]->pCreateInfo, string_XGL_STATE_BIND_POINT((XGL_STATE_BIND_POINT)i));
+ pGVstr = dynamic_gv_display(g_lastBoundDynamicState[i]->pCreateInfo, string_VK_STATE_BIND_POINT((VK_STATE_BIND_POINT)i));
fprintf(pOutFile, "%s", pGVstr);
free(pGVstr);
}
}
fprintf(pOutFile, "}\n"); // close dynamicState subgraph
fprintf(pOutFile, "subgraph cluster_PipelineStateObject\n{\nlabel=\"Pipeline State Object\"\n");
- pGVstr = xgl_gv_print_xgl_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "PSO HEAD");
+ pGVstr = vk_gv_print_vk_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "PSO HEAD");
fprintf(pOutFile, "%s", pGVstr);
free(pGVstr);
fprintf(pOutFile, "}\n");
@@ -1301,7 +1301,7 @@
}
}
// Dump a GraphViz dot file showing the pipeline for a given CB
-static void dumpDotFile(const XGL_CMD_BUFFER cb, string outFileName)
+static void dumpDotFile(const VK_CMD_BUFFER cb, string outFileName)
{
GLOBAL_CB_NODE* pCB = getCBNode(cb);
if (pCB) {
@@ -1312,16 +1312,16 @@
fprintf(pOutFile, "digraph g {\ngraph [\nrankdir = \"TB\"\n];\nnode [\nfontsize = \"16\"\nshape = \"plaintext\"\n];\nedge [\n];\n");
fprintf(pOutFile, "subgraph cluster_dynamicState\n{\nlabel=\"Dynamic State\"\n");
char* pGVstr = NULL;
- for (uint32_t i = 0; i < XGL_NUM_STATE_BIND_POINT; i++) {
+ for (uint32_t i = 0; i < VK_NUM_STATE_BIND_POINT; i++) {
if (pCB->lastBoundDynamicState[i] && pCB->lastBoundDynamicState[i]->pCreateInfo) {
- pGVstr = dynamic_gv_display(pCB->lastBoundDynamicState[i]->pCreateInfo, string_XGL_STATE_BIND_POINT((XGL_STATE_BIND_POINT)i));
+ pGVstr = dynamic_gv_display(pCB->lastBoundDynamicState[i]->pCreateInfo, string_VK_STATE_BIND_POINT((VK_STATE_BIND_POINT)i));
fprintf(pOutFile, "%s", pGVstr);
free(pGVstr);
}
}
fprintf(pOutFile, "}\n"); // close dynamicState subgraph
fprintf(pOutFile, "subgraph cluster_PipelineStateObject\n{\nlabel=\"Pipeline State Object\"\n");
- pGVstr = xgl_gv_print_xgl_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "PSO HEAD");
+ pGVstr = vk_gv_print_vk_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "PSO HEAD");
fprintf(pOutFile, "%s", pGVstr);
free(pGVstr);
fprintf(pOutFile, "}\n");
@@ -1332,7 +1332,7 @@
}
}
// Verify VB Buffer binding
-static void validateVBBinding(const XGL_CMD_BUFFER cb)
+static void validateVBBinding(const VK_CMD_BUFFER cb)
{
GLOBAL_CB_NODE* pCB = getCBNode(cb);
if (pCB && pCB->lastBoundPipeline) {
@@ -1341,7 +1341,7 @@
char str[1024];
if (!pPipeTrav) {
sprintf(str, "Can't find last bound Pipeline %p!", (void*)pCB->lastBoundPipeline);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NO_PIPELINE_BOUND, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NO_PIPELINE_BOUND, "DS", str);
}
else {
// Verify Vtx binding
@@ -1349,23 +1349,23 @@
if (pCB->lastVtxBinding >= pPipeTrav->vtxBindingCount) {
if (0 == pPipeTrav->vtxBindingCount) {
sprintf(str, "Vtx Buffer Index %u was bound, but no vtx buffers are attached to PSO.", pCB->lastVtxBinding);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS", str);
}
else {
sprintf(str, "Vtx binding Index of %u exceeds PSO pVertexBindingDescriptions max array index of %u.", pCB->lastVtxBinding, (pPipeTrav->vtxBindingCount - 1));
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS", str);
}
}
else {
- string tmpStr = xgl_print_xgl_vertex_input_binding_description(&pPipeTrav->pVertexBindingDescriptions[pCB->lastVtxBinding], "{DS}INFO : ").c_str();
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmpStr.c_str());
+ string tmpStr = vk_print_vk_vertex_input_binding_description(&pPipeTrav->pVertexBindingDescriptions[pCB->lastVtxBinding], "{DS}INFO : ").c_str();
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmpStr.c_str());
}
}
}
}
}
// Print details of DS config to stdout
-static void printDSConfig(const XGL_CMD_BUFFER cb)
+static void printDSConfig(const VK_CMD_BUFFER cb)
{
char tmp_str[1024];
char ds_config_str[1024*256] = {0}; // TODO : Currently making this buffer HUGE w/o overrun protection. Need to be smarter, start smaller, and grow as needed.
@@ -1375,50 +1375,50 @@
POOL_NODE* pPool = getPoolNode(pSet->pool);
// Print out pool details
sprintf(tmp_str, "Details for pool %p.", (void*)pPool->pool);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
- string poolStr = xgl_print_xgl_descriptor_pool_create_info(&pPool->createInfo, " ");
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
+ string poolStr = vk_print_vk_descriptor_pool_create_info(&pPool->createInfo, " ");
sprintf(ds_config_str, "%s", poolStr.c_str());
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str);
// Print out set details
char prefix[10];
uint32_t index = 0;
sprintf(tmp_str, "Details for descriptor set %p.", (void*)pSet->set);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
LAYOUT_NODE* pLayout = pSet->pLayout;
// Print layout details
sprintf(tmp_str, "Layout #%u, (object %p) for DS %p.", index+1, (void*)pLayout->layout, (void*)pSet->set);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
sprintf(prefix, " [L%u] ", index);
- string DSLstr = xgl_print_xgl_descriptor_set_layout_create_info(&pLayout->createInfo, prefix).c_str();
+ string DSLstr = vk_print_vk_descriptor_set_layout_create_info(&pLayout->createInfo, prefix).c_str();
sprintf(ds_config_str, "%s", DSLstr.c_str());
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str);
index++;
GENERIC_HEADER* pUpdate = pSet->pUpdateStructs;
if (pUpdate) {
sprintf(tmp_str, "Update Chain [UC] for descriptor set %p:", (void*)pSet->set);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
sprintf(prefix, " [UC] ");
sprintf(ds_config_str, "%s", dynamic_display(pUpdate, prefix).c_str());
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str);
// TODO : If there is a "view" associated with this update, print CI for that view
}
else {
- sprintf(tmp_str, "No Update Chain for descriptor set %p (xglUpdateDescriptors has not been called)", (void*)pSet->set);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
+ sprintf(tmp_str, "No Update Chain for descriptor set %p (vkUpdateDescriptors has not been called)", (void*)pSet->set);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
}
}
}
-static void printCB(const XGL_CMD_BUFFER cb)
+static void printCB(const VK_CMD_BUFFER cb)
{
GLOBAL_CB_NODE* pCB = getCBNode(cb);
if (pCB) {
char str[1024];
sprintf(str, "Cmds in CB %p", (void*)cb);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", str);
for (vector<CMD_NODE*>::iterator ii=pCB->pCmds.begin(); ii!=pCB->pCmds.end(); ++ii) {
sprintf(str, " CMD#%lu: %s", (*ii)->cmdNumber, cmdTypeToString((*ii)->type).c_str());
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cb, 0, DRAWSTATE_NONE, "DS", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cb, 0, DRAWSTATE_NONE, "DS", str);
}
}
else {
@@ -1427,7 +1427,7 @@
}
-static void synchAndPrintDSConfig(const XGL_CMD_BUFFER cb)
+static void synchAndPrintDSConfig(const VK_CMD_BUFFER cb)
{
printDSConfig(cb);
printPipeline(cb);
@@ -1455,7 +1455,7 @@
getLayerOptionEnum("DrawStateReportLevel", (uint32_t *) &g_reportingLevel);
g_actionIsDefault = getLayerOptionEnum("DrawStateDebugAction", (uint32_t *) &g_debugAction);
- if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
+ if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
{
strOpt = getLayerOption("DrawStateLogFilename");
if (strOpt)
@@ -1467,20 +1467,20 @@
}
// initialize Layer dispatch table
// TODO handle multiple GPUs
- xglGetProcAddrType fpNextGPA;
+ vkGetProcAddrType fpNextGPA;
fpNextGPA = pCurObj->pGPA;
assert(fpNextGPA);
- layer_initialize_dispatch_table(&nextTable, fpNextGPA, (XGL_PHYSICAL_GPU) pCurObj->nextObject);
+ layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);
- xglGetProcAddrType fpGetProcAddr = (xglGetProcAddrType)fpNextGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (char *) "xglGetProcAddr");
+ vkGetProcAddrType fpGetProcAddr = (vkGetProcAddrType)fpNextGPA((VK_PHYSICAL_GPU) pCurObj->nextObject, (char *) "vkGetProcAddr");
nextTable.GetProcAddr = fpGetProcAddr;
if (!globalLockInitialized)
{
// TODO/TBD: Need to delete this mutex sometime. How??? One
- // suggestion is to call this during xglCreateInstance(), and then we
- // can clean it up during xglDestroyInstance(). However, that requires
+ // suggestion is to call this during vkCreateInstance(), and then we
+ // can clean it up during vkDestroyInstance(). However, that requires
// that the layer have per-instance locks. We need to come back and
// address this soon.
loader_platform_thread_create_mutex(&globalLock);
@@ -1488,16 +1488,16 @@
}
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
pCurObj = gpuw;
loader_platform_thread_once(&g_initOnce, initDrawState);
- XGL_RESULT result = nextTable.CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
+ VK_RESULT result = nextTable.CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyDevice(XGL_DEVICE device)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device)
{
// Free all the memory
loader_platform_thread_lock_mutex(&globalLock);
@@ -1510,69 +1510,69 @@
freePools();
freeLayouts();
loader_platform_thread_unlock_mutex(&globalLock);
- XGL_RESULT result = nextTable.DestroyDevice(device);
+ VK_RESULT result = nextTable.DestroyDevice(device);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu, const char* pExtName)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
- XGL_RESULT result;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+ VK_RESULT result;
/* This entrypoint is NOT going to init its own dispatch table since loader calls here early */
if (!strcmp(pExtName, "DrawState") || !strcmp(pExtName, "drawStateDumpDotFile") ||
!strcmp(pExtName, "drawStateDumpCommandBufferDotFile") || !strcmp(pExtName, "drawStateDumpPngFile"))
{
- result = XGL_SUCCESS;
+ result = VK_SUCCESS;
} else if (nextTable.GetExtensionSupport != NULL)
{
- result = nextTable.GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);
+ result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);
} else
{
- result = XGL_ERROR_INVALID_EXTENSION;
+ result = VK_ERROR_INVALID_EXTENSION;
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
{
if (gpu != NULL)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
pCurObj = gpuw;
loader_platform_thread_once(&g_initOnce, initDrawState);
- XGL_RESULT result = nextTable.EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+ VK_RESULT result = nextTable.EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
return result;
} else
{
if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
- return XGL_ERROR_INVALID_POINTER;
+ return VK_ERROR_INVALID_POINTER;
// This layer compatible with all GPUs
*pOutLayerCount = 1;
strncpy((char *) pOutLayers[0], "DrawState", maxStringSize);
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit(VK_QUEUE queue, uint32_t cmdBufferCount, const VK_CMD_BUFFER* pCmdBuffers, VK_FENCE fence)
{
for (uint32_t i=0; i < cmdBufferCount; i++) {
// Validate that cmd buffers have been updated
}
- XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
+ VK_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyObject(XGL_OBJECT object)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object)
{
// TODO : When wrapped objects (such as dynamic state) are destroyed, need to clean up memory
- XGL_RESULT result = nextTable.DestroyObject(object);
+ VK_RESULT result = nextTable.DestroyObject(object);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateBufferView(XGL_DEVICE device, const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo, XGL_BUFFER_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView)
{
- XGL_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
+ if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
BUFFER_NODE* pNewNode = new BUFFER_NODE;
pNewNode->buffer = *pView;
@@ -1583,10 +1583,10 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImageView(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView)
{
- XGL_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
+ if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
IMAGE_NODE *pNewNode = new IMAGE_NODE;
pNewNode->image = *pView;
@@ -1597,51 +1597,51 @@
return result;
}
-static void track_pipeline(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+static void track_pipeline(const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline)
{
+ // Create LL HEAD for this Pipeline
+ loader_platform_thread_lock_mutex(&globalLock);
PIPELINE_NODE* pPipeNode = new PIPELINE_NODE;
memset((void*)pPipeNode, 0, sizeof(PIPELINE_NODE));
pPipeNode->pipeline = *pPipeline;
initPipeline(pPipeNode, pCreateInfo);
+ loader_platform_thread_unlock_mutex(&globalLock);
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline)
{
- XGL_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+ VK_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
// Create LL HEAD for this Pipeline
char str[1024];
sprintf(str, "Created Gfx Pipeline %p", (void*)*pPipeline);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, (XGL_BASE_OBJECT)pPipeline, 0, DRAWSTATE_NONE, "DS", str);
- loader_platform_thread_lock_mutex(&globalLock);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, *pPipeline, 0, DRAWSTATE_NONE, "DS", str);
track_pipeline(pCreateInfo, pPipeline);
- loader_platform_thread_unlock_mutex(&globalLock);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(
- XGL_DEVICE device,
- const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
- XGL_PIPELINE basePipeline,
- XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative(
+ VK_DEVICE device,
+ const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+ VK_PIPELINE basePipeline,
+ VK_PIPELINE* pPipeline)
{
- XGL_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
+ VK_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
// Create LL HEAD for this Pipeline
char str[1024];
sprintf(str, "Created Gfx Pipeline %p (derived from pipeline %p)", (void*)*pPipeline, basePipeline);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, (XGL_BASE_OBJECT)pPipeline, 0, DRAWSTATE_NONE, "DS", str);
- loader_platform_thread_lock_mutex(&globalLock);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, *pPipeline, 0, DRAWSTATE_NONE, "DS", str);
track_pipeline(pCreateInfo, pPipeline);
loader_platform_thread_unlock_mutex(&globalLock);
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateSampler(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler)
{
- XGL_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
+ if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
SAMPLER_NODE* pNewNode = new SAMPLER_NODE;
pNewNode->sampler = *pSampler;
@@ -1652,31 +1652,31 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSetLayout(XGL_DEVICE device, const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout(VK_DEVICE device, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_SET_LAYOUT* pSetLayout)
{
- XGL_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+ if (VK_SUCCESS == result) {
LAYOUT_NODE* pNewNode = new LAYOUT_NODE;
if (NULL == pNewNode) {
char str[1024];
- sprintf(str, "Out of memory while attempting to allocate LAYOUT_NODE in xglCreateDescriptorSetLayout()");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, *pSetLayout, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
+ sprintf(str, "Out of memory while attempting to allocate LAYOUT_NODE in vkCreateDescriptorSetLayout()");
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, *pSetLayout, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
}
memset(pNewNode, 0, sizeof(LAYOUT_NODE));
- memcpy((void*)&pNewNode->createInfo, pCreateInfo, sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO));
- pNewNode->createInfo.pBinding = new XGL_DESCRIPTOR_SET_LAYOUT_BINDING[pCreateInfo->count];
- memcpy((void*)pNewNode->createInfo.pBinding, pCreateInfo->pBinding, sizeof(XGL_DESCRIPTOR_SET_LAYOUT_BINDING)*pCreateInfo->count);
+ memcpy((void*)&pNewNode->createInfo, pCreateInfo, sizeof(VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO));
+ pNewNode->createInfo.pBinding = new VK_DESCRIPTOR_SET_LAYOUT_BINDING[pCreateInfo->count];
+ memcpy((void*)pNewNode->createInfo.pBinding, pCreateInfo->pBinding, sizeof(VK_DESCRIPTOR_SET_LAYOUT_BINDING)*pCreateInfo->count);
uint32_t totalCount = 0;
for (uint32_t i=0; i<pCreateInfo->count; i++) {
totalCount += pCreateInfo->pBinding[i].count;
if (pCreateInfo->pBinding[i].pImmutableSamplers) {
void** ppImmutableSamplers = (void**)&pNewNode->createInfo.pBinding[i].pImmutableSamplers;
- *ppImmutableSamplers = malloc(sizeof(XGL_SAMPLER)*pCreateInfo->pBinding[i].count);
- memcpy(*ppImmutableSamplers, pCreateInfo->pBinding[i].pImmutableSamplers, pCreateInfo->pBinding[i].count*sizeof(XGL_SAMPLER));
+ *ppImmutableSamplers = malloc(sizeof(VK_SAMPLER)*pCreateInfo->pBinding[i].count);
+ memcpy(*ppImmutableSamplers, pCreateInfo->pBinding[i].pImmutableSamplers, pCreateInfo->pBinding[i].count*sizeof(VK_SAMPLER));
}
}
if (totalCount > 0) {
- pNewNode->pTypes = new XGL_DESCRIPTOR_TYPE[totalCount];
+ pNewNode->pTypes = new VK_DESCRIPTOR_TYPE[totalCount];
uint32_t offset = 0;
uint32_t j = 0;
for (uint32_t i=0; i<pCreateInfo->count; i++) {
@@ -1698,25 +1698,25 @@
return result;
}
-XGL_RESULT XGLAPI xglCreateDescriptorSetLayoutChain(XGL_DEVICE device, uint32_t setLayoutArrayCount, const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, XGL_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain)
+VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain(VK_DEVICE device, uint32_t setLayoutArrayCount, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain)
{
- XGL_RESULT result = nextTable.CreateDescriptorSetLayoutChain(device, setLayoutArrayCount, pSetLayoutArray, pLayoutChain);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.CreateDescriptorSetLayoutChain(device, setLayoutArrayCount, pSetLayoutArray, pLayoutChain);
+ if (VK_SUCCESS == result) {
// TODO : Need to capture the layout chains
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginDescriptorPoolUpdate(XGL_DEVICE device, XGL_DESCRIPTOR_UPDATE_MODE updateMode)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(VK_DEVICE device, VK_DESCRIPTOR_UPDATE_MODE updateMode)
{
- XGL_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode);
+ if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
POOL_NODE* pPoolNode = poolMap.begin()->second;
if (!pPoolNode) {
char str[1024];
sprintf(str, "Unable to find pool node");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INTERNAL_ERROR, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INTERNAL_ERROR, "DS", str);
}
else {
pPoolNode->updateActive = 1;
@@ -1726,22 +1726,22 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEndDescriptorPoolUpdate(XGL_DEVICE device, XGL_CMD_BUFFER cmd)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEndDescriptorPoolUpdate(VK_DEVICE device, VK_CMD_BUFFER cmd)
{
- XGL_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd);
+ if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
POOL_NODE* pPoolNode = poolMap.begin()->second;
if (!pPoolNode) {
char str[1024];
sprintf(str, "Unable to find pool node");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INTERNAL_ERROR, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INTERNAL_ERROR, "DS", str);
}
else {
if (!pPoolNode->updateActive) {
char str[1024];
- sprintf(str, "You must call xglBeginDescriptorPoolUpdate() before this call to xglEndDescriptorPoolUpdate()!");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_DS_END_WITHOUT_BEGIN, "DS", str);
+ sprintf(str, "You must call vkBeginDescriptorPoolUpdate() before this call to vkEndDescriptorPoolUpdate()!");
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_DS_END_WITHOUT_BEGIN, "DS", str);
}
else {
pPoolNode->updateActive = 0;
@@ -1753,28 +1753,28 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorPool(XGL_DEVICE device, XGL_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const XGL_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_POOL* pDescriptorPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_POOL* pDescriptorPool)
{
- XGL_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
+ if (VK_SUCCESS == result) {
// Insert this pool into Global Pool LL at head
char str[1024];
sprintf(str, "Created Descriptor Pool %p", (void*)*pDescriptorPool);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, (XGL_BASE_OBJECT)pDescriptorPool, 0, DRAWSTATE_NONE, "DS", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (VK_BASE_OBJECT)pDescriptorPool, 0, DRAWSTATE_NONE, "DS", str);
loader_platform_thread_lock_mutex(&globalLock);
POOL_NODE* pNewNode = new POOL_NODE;
if (NULL == pNewNode) {
char str[1024];
- sprintf(str, "Out of memory while attempting to allocate POOL_NODE in xglCreateDescriptorPool()");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, (XGL_BASE_OBJECT)*pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
+ sprintf(str, "Out of memory while attempting to allocate POOL_NODE in vkCreateDescriptorPool()");
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, (VK_BASE_OBJECT)*pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
}
else {
memset(pNewNode, 0, sizeof(POOL_NODE));
- XGL_DESCRIPTOR_POOL_CREATE_INFO* pCI = (XGL_DESCRIPTOR_POOL_CREATE_INFO*)&pNewNode->createInfo;
- memcpy((void*)pCI, pCreateInfo, sizeof(XGL_DESCRIPTOR_POOL_CREATE_INFO));
+ VK_DESCRIPTOR_POOL_CREATE_INFO* pCI = (VK_DESCRIPTOR_POOL_CREATE_INFO*)&pNewNode->createInfo;
+ memcpy((void*)pCI, pCreateInfo, sizeof(VK_DESCRIPTOR_POOL_CREATE_INFO));
if (pNewNode->createInfo.count) {
- size_t typeCountSize = pNewNode->createInfo.count * sizeof(XGL_DESCRIPTOR_TYPE_COUNT);
- pNewNode->createInfo.pTypeCount = new XGL_DESCRIPTOR_TYPE_COUNT[typeCountSize];
+ size_t typeCountSize = pNewNode->createInfo.count * sizeof(VK_DESCRIPTOR_TYPE_COUNT);
+ pNewNode->createInfo.pTypeCount = new VK_DESCRIPTOR_TYPE_COUNT[typeCountSize];
memcpy((void*)pNewNode->createInfo.pTypeCount, pCreateInfo->pTypeCount, typeCountSize);
}
pNewNode->poolUsage = poolUsage;
@@ -1791,36 +1791,36 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetDescriptorPool(XGL_DESCRIPTOR_POOL descriptorPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetDescriptorPool(VK_DESCRIPTOR_POOL descriptorPool)
{
- XGL_RESULT result = nextTable.ResetDescriptorPool(descriptorPool);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.ResetDescriptorPool(descriptorPool);
+ if (VK_SUCCESS == result) {
clearDescriptorPool(descriptorPool);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglAllocDescriptorSets(XGL_DESCRIPTOR_POOL descriptorPool, XGL_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts, XGL_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount)
{
- XGL_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
- if ((XGL_SUCCESS == result) || (*pCount > 0)) {
+ VK_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
+ if ((VK_SUCCESS == result) || (*pCount > 0)) {
POOL_NODE *pPoolNode = getPoolNode(descriptorPool);
if (!pPoolNode) {
char str[1024];
- sprintf(str, "Unable to find pool node for pool %p specified in xglAllocDescriptorSets() call", (void*)descriptorPool);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, descriptorPool, 0, DRAWSTATE_INVALID_POOL, "DS", str);
+ sprintf(str, "Unable to find pool node for pool %p specified in vkAllocDescriptorSets() call", (void*)descriptorPool);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, descriptorPool, 0, DRAWSTATE_INVALID_POOL, "DS", str);
}
else {
for (uint32_t i = 0; i < *pCount; i++) {
char str[1024];
sprintf(str, "Created Descriptor Set %p", (void*)pDescriptorSets[i]);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", str);
// Create new set node and add to head of pool nodes
SET_NODE* pNewNode = new SET_NODE;
if (NULL == pNewNode) {
char str[1024];
- sprintf(str, "Out of memory while attempting to allocate SET_NODE in xglAllocDescriptorSets()");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
+ sprintf(str, "Out of memory while attempting to allocate SET_NODE in vkAllocDescriptorSets()");
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
}
else {
memset(pNewNode, 0, sizeof(SET_NODE));
@@ -1830,8 +1830,8 @@
LAYOUT_NODE* pLayout = getLayoutNode(pSetLayouts[i]);
if (NULL == pLayout) {
char str[1024];
- sprintf(str, "Unable to find set layout node for layout %p specified in xglAllocDescriptorSets() call", (void*)pSetLayouts[i]);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS", str);
+ sprintf(str, "Unable to find set layout node for layout %p specified in vkAllocDescriptorSets() call", (void*)pSetLayouts[i]);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS", str);
}
pNewNode->pLayout = pLayout;
pNewNode->pool = descriptorPool;
@@ -1851,7 +1851,7 @@
return result;
}
-XGL_LAYER_EXPORT void XGLAPI xglClearDescriptorSets(XGL_DESCRIPTOR_POOL descriptorPool, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets)
+VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets)
{
for (uint32_t i = 0; i < count; i++) {
clearDescriptorSet(pDescriptorSets[i]);
@@ -1859,54 +1859,54 @@
nextTable.ClearDescriptorSets(descriptorPool, count, pDescriptorSets);
}
-XGL_LAYER_EXPORT void XGLAPI xglUpdateDescriptors(XGL_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray)
+VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray)
{
SET_NODE* pSet = getSetNode(descriptorSet);
if (!dsUpdateActive(descriptorSet)) {
char str[1024];
- sprintf(str, "You must call xglBeginDescriptorPoolUpdate() before this call to xglUpdateDescriptors()!");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pSet->pool, 0, DRAWSTATE_UPDATE_WITHOUT_BEGIN, "DS", str);
+ sprintf(str, "You must call vkBeginDescriptorPoolUpdate() before this call to vkUpdateDescriptors()!");
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pSet->pool, 0, DRAWSTATE_UPDATE_WITHOUT_BEGIN, "DS", str);
}
else {
- // pUpdateChain is a Linked-list of XGL_UPDATE_* structures defining the mappings for the descriptors
+ // pUpdateChain is a Linked-list of VK_UPDATE_* structures defining the mappings for the descriptors
dsUpdate(descriptorSet, updateCount, ppUpdateArray);
}
nextTable.UpdateDescriptors(descriptorSet, updateCount, ppUpdateArray);
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicViewportState(XGL_DEVICE device, const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_VP_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_VP_STATE_OBJECT* pState)
{
- XGL_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
- insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, XGL_STATE_BIND_VIEWPORT);
+ VK_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
+ insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_VIEWPORT);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicRasterState(XGL_DEVICE device, const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_RS_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_RS_STATE_OBJECT* pState)
{
- XGL_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
- insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, XGL_STATE_BIND_RASTER);
+ VK_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
+ insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_RASTER);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicColorBlendState(XGL_DEVICE device, const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_CB_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_CB_STATE_OBJECT* pState)
{
- XGL_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
- insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, XGL_STATE_BIND_COLOR_BLEND);
+ VK_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
+ insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_COLOR_BLEND);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState(XGL_DEVICE device, const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_DS_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_DS_STATE_OBJECT* pState)
{
- XGL_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
- insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, XGL_STATE_BIND_DEPTH_STENCIL);
+ VK_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
+ insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_DEPTH_STENCIL);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateCommandBuffer(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer)
{
- XGL_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+ if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
GLOBAL_CB_NODE* pCB = new GLOBAL_CB_NODE;
memset(pCB, 0, sizeof(GLOBAL_CB_NODE));
@@ -1921,36 +1921,36 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginCommandBuffer(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
{
- XGL_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
+ if (VK_SUCCESS == result) {
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
if (CB_NEW != pCB->state)
resetCB(cmdBuffer);
pCB->state = CB_UPDATE_ACTIVE;
if (pBeginInfo->pNext) {
- XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pCbGfxBI = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pBeginInfo->pNext;
- if (XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO == pCbGfxBI->sType) {
+ VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pCbGfxBI = (VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pBeginInfo->pNext;
+ if (VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO == pCbGfxBI->sType) {
pCB->activeRenderPass = pCbGfxBI->renderPassContinue.renderPass;
}
}
}
else {
char str[1024];
- sprintf(str, "In xglBeginCommandBuffer() and unable to find CmdBuffer Node for CB %p!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ sprintf(str, "In vkBeginCommandBuffer() and unable to find CmdBuffer Node for CB %p!", (void*)cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
updateCBTracking(cmdBuffer);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEndCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer)
{
- XGL_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
+ if (VK_SUCCESS == result) {
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
pCB->state = CB_UPDATE_COMPLETE;
@@ -1958,8 +1958,8 @@
}
else {
char str[1024];
- sprintf(str, "In xglEndCommandBuffer() and unable to find CmdBuffer Node for CB %p!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ sprintf(str, "In vkEndCommandBuffer() and unable to find CmdBuffer Node for CB %p!", (void*)cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
updateCBTracking(cmdBuffer);
//cbDumpDotFile("cb_dump.dot");
@@ -1967,17 +1967,17 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer)
{
- XGL_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
+ if (VK_SUCCESS == result) {
resetCB(cmdBuffer);
updateCBTracking(cmdBuffer);
}
return result;
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindPipeline(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline)
+VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -1994,24 +1994,24 @@
else {
char str[1024];
sprintf(str, "Attempt to bind Pipeline %p that doesn't exist!", (void*)pipeline);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pipeline, 0, DRAWSTATE_INVALID_PIPELINE, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pipeline, 0, DRAWSTATE_INVALID_PIPELINE, "DS", str);
}
}
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDynamicStateObject(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state)
{
setLastBoundDynamicState(cmdBuffer, state, stateBindPoint);
nextTable.CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDescriptorSets(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2023,8 +2023,8 @@
// TODO : This check here needs to be made at QueueSubmit time
/*
char str[1024];
- sprintf(str, "You must call xglEndDescriptorPoolUpdate(%p) before this call to xglCmdBindDescriptorSet()!", (void*)descriptorSet);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, descriptorSet, 0, DRAWSTATE_BINDING_DS_NO_END_UPDATE, "DS", str);
+ sprintf(str, "You must call vkEndDescriptorPoolUpdate(%p) before this call to vkCmdBindDescriptorSet()!", (void*)descriptorSet);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, descriptorSet, 0, DRAWSTATE_BINDING_DS_NO_END_UPDATE, "DS", str);
*/
}
loader_platform_thread_lock_mutex(&globalLock);
@@ -2032,26 +2032,26 @@
g_lastBoundDescriptorSet = pDescriptorSets[i];
loader_platform_thread_unlock_mutex(&globalLock);
char str[1024];
- sprintf(str, "DS %p bound on pipeline %s", (void*)pDescriptorSets[i], string_XGL_PIPELINE_BIND_POINT(pipelineBindPoint));
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", str);
+ sprintf(str, "DS %p bound on pipeline %s", (void*)pDescriptorSets[i], string_VK_PIPELINE_BIND_POINT(pipelineBindPoint));
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", str);
synchAndPrintDSConfig(cmdBuffer);
}
else {
char str[1024];
sprintf(str, "Attempt to bind DS %p that doesn't exist!", (void*)pDescriptorSets[i]);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_INVALID_SET, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_INVALID_SET, "DS", str);
}
}
}
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindIndexBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType)
+VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2062,12 +2062,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindVertexBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t binding)
+VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2079,12 +2079,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDraw(XGL_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
+VK_LAYER_EXPORT void VKAPI vkCmdDraw(VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2092,19 +2092,19 @@
addCmd(pCB, CMD_DRAW);
pCB->drawCount[DRAW]++;
char str[1024];
- sprintf(str, "xglCmdDraw() call #%lu, reporting DS state:", g_drawCount[DRAW]++);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
+ sprintf(str, "vkCmdDraw() call #%lu, reporting DS state:", g_drawCount[DRAW]++);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
synchAndPrintDSConfig(cmdBuffer);
}
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndexed(XGL_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2112,19 +2112,19 @@
addCmd(pCB, CMD_DRAWINDEXED);
pCB->drawCount[DRAW_INDEXED]++;
char str[1024];
- sprintf(str, "xglCmdDrawIndexed() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED]++);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
+ sprintf(str, "vkCmdDrawIndexed() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED]++);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
synchAndPrintDSConfig(cmdBuffer);
}
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2132,19 +2132,19 @@
addCmd(pCB, CMD_DRAWINDIRECT);
pCB->drawCount[DRAW_INDIRECT]++;
char str[1024];
- sprintf(str, "xglCmdDrawIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDIRECT]++);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
+ sprintf(str, "vkCmdDrawIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDIRECT]++);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
synchAndPrintDSConfig(cmdBuffer);
}
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndexedIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2152,19 +2152,19 @@
addCmd(pCB, CMD_DRAWINDEXEDINDIRECT);
pCB->drawCount[DRAW_INDEXED_INDIRECT]++;
char str[1024];
- sprintf(str, "xglCmdDrawIndexedIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED_INDIRECT]++);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
+ sprintf(str, "vkCmdDrawIndexedIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED_INDIRECT]++);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
synchAndPrintDSConfig(cmdBuffer);
}
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDispatch(XGL_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2174,12 +2174,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdDispatch(cmdBuffer, x, y, z);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDispatchIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2189,12 +2189,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_COPY* pRegions)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2204,16 +2204,17 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImage(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
- XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
- uint32_t regionCount, const XGL_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE srcImage,
+ VK_IMAGE_LAYOUT srcImageLayout,
+ VK_IMAGE destImage,
+ VK_IMAGE_LAYOUT destImageLayout,
+ uint32_t regionCount, const VK_IMAGE_COPY* pRegions)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2223,15 +2224,15 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBlitImage(XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
- XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
- uint32_t regionCount, const XGL_IMAGE_BLIT* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout,
+ VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout,
+ uint32_t regionCount, const VK_IMAGE_BLIT* pRegions)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2241,16 +2242,15 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBufferToImage(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_BUFFER srcBuffer,
- XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
- uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer,
+ VK_BUFFER srcBuffer,
+ VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout,
+ uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2260,16 +2260,15 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImageToBuffer(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
- XGL_BUFFER destBuffer,
- uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout,
+ VK_BUFFER destBuffer,
+ uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2279,12 +2278,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCloneImageData(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout)
+VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2294,12 +2293,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdUpdateBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2309,12 +2308,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdFillBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, uint32_t data)
+VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2324,16 +2323,15 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearColorImage(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout,
- XGL_CLEAR_COLOR color,
- uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout,
+ VK_CLEAR_COLOR color,
+ uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2343,16 +2341,15 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearDepthStencil(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout,
- float depth, uint32_t stencil,
- uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout,
+ float depth, uint32_t stencil,
+ uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2362,16 +2359,15 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdResolveImage(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
- XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
- uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects)
+VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout,
+ VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout,
+ uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2381,12 +2377,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdSetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent)
+VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2396,12 +2392,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdSetEvent(cmdBuffer, event, pipeEvent);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdResetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent)
+VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2411,12 +2407,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdResetEvent(cmdBuffer, event, pipeEvent);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdWaitEvents(XGL_CMD_BUFFER cmdBuffer, const XGL_EVENT_WAIT_INFO* pWaitInfo)
+VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVENT_WAIT_INFO* pWaitInfo)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2426,12 +2422,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdWaitEvents(cmdBuffer, pWaitInfo);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdPipelineBarrier(XGL_CMD_BUFFER cmdBuffer, const XGL_PIPELINE_BARRIER* pBarrier)
+VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const VK_PIPELINE_BARRIER* pBarrier)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2441,12 +2437,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdPipelineBarrier(cmdBuffer, pBarrier);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot, XGL_FLAGS flags)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2456,12 +2452,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdEndQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot)
+VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2471,12 +2467,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdEndQuery(cmdBuffer, queryPool, slot);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdResetQueryPool(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount)
+VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2486,12 +2482,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdWriteTimestamp(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset)
+VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMESTAMP_TYPE timestampType, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2501,12 +2497,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdInitAtomicCounters(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2516,12 +2512,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData);
}
-XGL_LAYER_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)
+VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER srcBuffer, VK_GPU_SIZE srcOffset)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2531,12 +2527,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset);
}
-XGL_LAYER_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)
+VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2546,54 +2542,54 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset);
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateFramebuffer(XGL_DEVICE device, const XGL_FRAMEBUFFER_CREATE_INFO* pCreateInfo, XGL_FRAMEBUFFER* pFramebuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(VK_DEVICE device, const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, VK_FRAMEBUFFER* pFramebuffer)
{
- XGL_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+ if (VK_SUCCESS == result) {
// Shadow create info and store in map
- XGL_FRAMEBUFFER_CREATE_INFO* localFBCI = new XGL_FRAMEBUFFER_CREATE_INFO(*pCreateInfo);
+ VK_FRAMEBUFFER_CREATE_INFO* localFBCI = new VK_FRAMEBUFFER_CREATE_INFO(*pCreateInfo);
if (pCreateInfo->pColorAttachments) {
- localFBCI->pColorAttachments = new XGL_COLOR_ATTACHMENT_BIND_INFO[localFBCI->colorAttachmentCount];
- memcpy((void*)localFBCI->pColorAttachments, pCreateInfo->pColorAttachments, localFBCI->colorAttachmentCount*sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO));
+ localFBCI->pColorAttachments = new VK_COLOR_ATTACHMENT_BIND_INFO[localFBCI->colorAttachmentCount];
+ memcpy((void*)localFBCI->pColorAttachments, pCreateInfo->pColorAttachments, localFBCI->colorAttachmentCount*sizeof(VK_COLOR_ATTACHMENT_BIND_INFO));
}
if (pCreateInfo->pDepthStencilAttachment) {
- localFBCI->pDepthStencilAttachment = new XGL_DEPTH_STENCIL_BIND_INFO[localFBCI->colorAttachmentCount];
- memcpy((void*)localFBCI->pDepthStencilAttachment, pCreateInfo->pDepthStencilAttachment, localFBCI->colorAttachmentCount*sizeof(XGL_DEPTH_STENCIL_BIND_INFO));
+ localFBCI->pDepthStencilAttachment = new VK_DEPTH_STENCIL_BIND_INFO[localFBCI->colorAttachmentCount];
+ memcpy((void*)localFBCI->pDepthStencilAttachment, pCreateInfo->pDepthStencilAttachment, localFBCI->colorAttachmentCount*sizeof(VK_DEPTH_STENCIL_BIND_INFO));
}
frameBufferMap[*pFramebuffer] = localFBCI;
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateRenderPass(XGL_DEVICE device, const XGL_RENDER_PASS_CREATE_INFO* pCreateInfo, XGL_RENDER_PASS* pRenderPass)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, VK_RENDER_PASS* pRenderPass)
{
- XGL_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass);
+ if (VK_SUCCESS == result) {
// Shadow create info and store in map
- XGL_RENDER_PASS_CREATE_INFO* localRPCI = new XGL_RENDER_PASS_CREATE_INFO(*pCreateInfo);
+ VK_RENDER_PASS_CREATE_INFO* localRPCI = new VK_RENDER_PASS_CREATE_INFO(*pCreateInfo);
if (pCreateInfo->pColorLoadOps) {
- localRPCI->pColorLoadOps = new XGL_ATTACHMENT_LOAD_OP[localRPCI->colorAttachmentCount];
- memcpy((void*)localRPCI->pColorLoadOps, pCreateInfo->pColorLoadOps, localRPCI->colorAttachmentCount*sizeof(XGL_ATTACHMENT_LOAD_OP));
+ localRPCI->pColorLoadOps = new VK_ATTACHMENT_LOAD_OP[localRPCI->colorAttachmentCount];
+ memcpy((void*)localRPCI->pColorLoadOps, pCreateInfo->pColorLoadOps, localRPCI->colorAttachmentCount*sizeof(VK_ATTACHMENT_LOAD_OP));
}
if (pCreateInfo->pColorStoreOps) {
- localRPCI->pColorStoreOps = new XGL_ATTACHMENT_STORE_OP[localRPCI->colorAttachmentCount];
- memcpy((void*)localRPCI->pColorStoreOps, pCreateInfo->pColorStoreOps, localRPCI->colorAttachmentCount*sizeof(XGL_ATTACHMENT_STORE_OP));
+ localRPCI->pColorStoreOps = new VK_ATTACHMENT_STORE_OP[localRPCI->colorAttachmentCount];
+ memcpy((void*)localRPCI->pColorStoreOps, pCreateInfo->pColorStoreOps, localRPCI->colorAttachmentCount*sizeof(VK_ATTACHMENT_STORE_OP));
}
if (pCreateInfo->pColorLoadClearValues) {
- localRPCI->pColorLoadClearValues = new XGL_CLEAR_COLOR[localRPCI->colorAttachmentCount];
- memcpy((void*)localRPCI->pColorLoadClearValues, pCreateInfo->pColorLoadClearValues, localRPCI->colorAttachmentCount*sizeof(XGL_CLEAR_COLOR));
+ localRPCI->pColorLoadClearValues = new VK_CLEAR_COLOR[localRPCI->colorAttachmentCount];
+ memcpy((void*)localRPCI->pColorLoadClearValues, pCreateInfo->pColorLoadClearValues, localRPCI->colorAttachmentCount*sizeof(VK_CLEAR_COLOR));
}
renderPassMap[*pRenderPass] = localRPCI;
}
return result;
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginRenderPass(XGL_CMD_BUFFER cmdBuffer, const XGL_RENDER_PASS_BEGIN *pRenderPassBegin)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const VK_RENDER_PASS_BEGIN *pRenderPassBegin)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2602,17 +2598,17 @@
pCB->activeRenderPass = pRenderPassBegin->renderPass;
pCB->framebuffer = pRenderPassBegin->framebuffer;
if (pCB->lastBoundPipeline) {
- validatePipelineState(pCB, XGL_PIPELINE_BIND_POINT_GRAPHICS, pCB->lastBoundPipeline);
+ validatePipelineState(pCB, VK_PIPELINE_BIND_POINT_GRAPHICS, pCB->lastBoundPipeline);
}
} else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdEndRenderPass(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass)
+VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VK_CMD_BUFFER cmdBuffer, VK_RENDER_PASS renderPass)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2623,36 +2619,36 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdEndRenderPass(cmdBuffer, renderPass);
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
{
// This layer intercepts callbacks
- XGL_LAYER_DBG_FUNCTION_NODE* pNewDbgFuncNode = (XGL_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(XGL_LAYER_DBG_FUNCTION_NODE));
+ VK_LAYER_DBG_FUNCTION_NODE* pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE));
#if ALLOC_DEBUG
printf("Alloc34 #%lu pNewDbgFuncNode addr(%p)\n", ++g_alloc_count, (void*)pNewDbgFuncNode);
#endif
if (!pNewDbgFuncNode)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;
pNewDbgFuncNode->pUserData = pUserData;
pNewDbgFuncNode->pNext = g_pDbgFunctionHead;
g_pDbgFunctionHead = pNewDbgFuncNode;
// force callbacks if DebugAction hasn't been set already other than initial value
if (g_actionIsDefault) {
- g_debugAction = XGL_DBG_LAYER_ACTION_CALLBACK;
+ g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK;
}
- XGL_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
+ VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
{
- XGL_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
- XGL_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;
+ VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
+ VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;
while (pTrav) {
if (pTrav->pfnMsgCallback == pfnMsgCallback) {
pPrev->pNext = pTrav->pNext;
@@ -2670,15 +2666,15 @@
if (g_pDbgFunctionHead == NULL)
{
if (g_actionIsDefault)
- g_debugAction = XGL_DBG_LAYER_ACTION_LOG_MSG;
+ g_debugAction = VK_DBG_LAYER_ACTION_LOG_MSG;
else
- g_debugAction = (XGL_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)XGL_DBG_LAYER_ACTION_CALLBACK));
+ g_debugAction = (VK_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)VK_DBG_LAYER_ACTION_CALLBACK));
}
- XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
+ VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
return result;
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDbgMarkerBegin(XGL_CMD_BUFFER cmdBuffer, const char* pMarker)
+VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VK_CMD_BUFFER cmdBuffer, const char* pMarker)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2688,12 +2684,12 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdDbgMarkerBegin(cmdBuffer, pMarker);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDbgMarkerEnd(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VK_CMD_BUFFER cmdBuffer)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2703,7 +2699,7 @@
else {
char str[1024];
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
nextTable.CmdDbgMarkerEnd(cmdBuffer);
}
@@ -2727,7 +2723,7 @@
// FIXME: NEED WINDOWS EQUIVALENT
char str[1024];
sprintf(str, "Cannot execute dot program yet on Windows.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_MISSING_DOT_PROGRAM, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_MISSING_DOT_PROGRAM, "DS", str);
#else // WIN32
char dotExe[32] = "/usr/bin/dot";
if( access(dotExe, X_OK) != -1) {
@@ -2740,158 +2736,158 @@
else {
char str[1024];
sprintf(str, "Cannot execute dot program at (%s) to dump requested %s file.", dotExe, outFileName);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_MISSING_DOT_PROGRAM, "DS", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_MISSING_DOT_PROGRAM, "DS", str);
}
#endif // WIN32
}
-XGL_LAYER_EXPORT void* XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* funcName)
+VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
if (gpu == NULL)
return NULL;
pCurObj = gpuw;
loader_platform_thread_once(&g_initOnce, initDrawState);
- if (!strcmp(funcName, "xglGetProcAddr"))
- return (void *) xglGetProcAddr;
- if (!strcmp(funcName, "xglCreateDevice"))
- return (void*) xglCreateDevice;
- if (!strcmp(funcName, "xglDestroyDevice"))
- return (void*) xglDestroyDevice;
- if (!strcmp(funcName, "xglGetExtensionSupport"))
- return (void*) xglGetExtensionSupport;
- if (!strcmp(funcName, "xglEnumerateLayers"))
- return (void*) xglEnumerateLayers;
- if (!strcmp(funcName, "xglQueueSubmit"))
- return (void*) xglQueueSubmit;
- if (!strcmp(funcName, "xglDestroyObject"))
- return (void*) xglDestroyObject;
- if (!strcmp(funcName, "xglCreateBufferView"))
- return (void*) xglCreateBufferView;
- if (!strcmp(funcName, "xglCreateImageView"))
- return (void*) xglCreateImageView;
- if (!strcmp(funcName, "xglCreateGraphicsPipeline"))
- return (void*) xglCreateGraphicsPipeline;
- if (!strcmp(funcName, "xglCreateGraphicsPipelineDerivative"))
- return (void*) xglCreateGraphicsPipelineDerivative;
- if (!strcmp(funcName, "xglCreateSampler"))
- return (void*) xglCreateSampler;
- if (!strcmp(funcName, "xglCreateDescriptorSetLayout"))
- return (void*) xglCreateDescriptorSetLayout;
- if (!strcmp(funcName, "xglCreateDescriptorSetLayoutChain"))
- return (void*) xglCreateDescriptorSetLayoutChain;
- if (!strcmp(funcName, "xglBeginDescriptorPoolUpdate"))
- return (void*) xglBeginDescriptorPoolUpdate;
- if (!strcmp(funcName, "xglEndDescriptorPoolUpdate"))
- return (void*) xglEndDescriptorPoolUpdate;
- if (!strcmp(funcName, "xglCreateDescriptorPool"))
- return (void*) xglCreateDescriptorPool;
- if (!strcmp(funcName, "xglResetDescriptorPool"))
- return (void*) xglResetDescriptorPool;
- if (!strcmp(funcName, "xglAllocDescriptorSets"))
- return (void*) xglAllocDescriptorSets;
- if (!strcmp(funcName, "xglClearDescriptorSets"))
- return (void*) xglClearDescriptorSets;
- if (!strcmp(funcName, "xglUpdateDescriptors"))
- return (void*) xglUpdateDescriptors;
- if (!strcmp(funcName, "xglCreateDynamicViewportState"))
- return (void*) xglCreateDynamicViewportState;
- if (!strcmp(funcName, "xglCreateDynamicRasterState"))
- return (void*) xglCreateDynamicRasterState;
- if (!strcmp(funcName, "xglCreateDynamicColorBlendState"))
- return (void*) xglCreateDynamicColorBlendState;
- if (!strcmp(funcName, "xglCreateDynamicDepthStencilState"))
- return (void*) xglCreateDynamicDepthStencilState;
- if (!strcmp(funcName, "xglCreateCommandBuffer"))
- return (void*) xglCreateCommandBuffer;
- if (!strcmp(funcName, "xglBeginCommandBuffer"))
- return (void*) xglBeginCommandBuffer;
- if (!strcmp(funcName, "xglEndCommandBuffer"))
- return (void*) xglEndCommandBuffer;
- if (!strcmp(funcName, "xglResetCommandBuffer"))
- return (void*) xglResetCommandBuffer;
- if (!strcmp(funcName, "xglCmdBindPipeline"))
- return (void*) xglCmdBindPipeline;
- if (!strcmp(funcName, "xglCmdBindDynamicStateObject"))
- return (void*) xglCmdBindDynamicStateObject;
- if (!strcmp(funcName, "xglCmdBindDescriptorSets"))
- return (void*) xglCmdBindDescriptorSets;
- if (!strcmp(funcName, "xglCmdBindVertexBuffer"))
- return (void*) xglCmdBindVertexBuffer;
- if (!strcmp(funcName, "xglCmdBindIndexBuffer"))
- return (void*) xglCmdBindIndexBuffer;
- if (!strcmp(funcName, "xglCmdDraw"))
- return (void*) xglCmdDraw;
- if (!strcmp(funcName, "xglCmdDrawIndexed"))
- return (void*) xglCmdDrawIndexed;
- if (!strcmp(funcName, "xglCmdDrawIndirect"))
- return (void*) xglCmdDrawIndirect;
- if (!strcmp(funcName, "xglCmdDrawIndexedIndirect"))
- return (void*) xglCmdDrawIndexedIndirect;
- if (!strcmp(funcName, "xglCmdDispatch"))
- return (void*) xglCmdDispatch;
- if (!strcmp(funcName, "xglCmdDispatchIndirect"))
- return (void*) xglCmdDispatchIndirect;
- if (!strcmp(funcName, "xglCmdCopyBuffer"))
- return (void*) xglCmdCopyBuffer;
- if (!strcmp(funcName, "xglCmdCopyImage"))
- return (void*) xglCmdCopyImage;
- if (!strcmp(funcName, "xglCmdCopyBufferToImage"))
- return (void*) xglCmdCopyBufferToImage;
- if (!strcmp(funcName, "xglCmdCopyImageToBuffer"))
- return (void*) xglCmdCopyImageToBuffer;
- if (!strcmp(funcName, "xglCmdCloneImageData"))
- return (void*) xglCmdCloneImageData;
- if (!strcmp(funcName, "xglCmdUpdateBuffer"))
- return (void*) xglCmdUpdateBuffer;
- if (!strcmp(funcName, "xglCmdFillBuffer"))
- return (void*) xglCmdFillBuffer;
- if (!strcmp(funcName, "xglCmdClearColorImage"))
- return (void*) xglCmdClearColorImage;
- if (!strcmp(funcName, "xglCmdClearDepthStencil"))
- return (void*) xglCmdClearDepthStencil;
- if (!strcmp(funcName, "xglCmdResolveImage"))
- return (void*) xglCmdResolveImage;
- if (!strcmp(funcName, "xglCmdSetEvent"))
- return (void*) xglCmdSetEvent;
- if (!strcmp(funcName, "xglCmdResetEvent"))
- return (void*) xglCmdResetEvent;
- if (!strcmp(funcName, "xglCmdWaitEvents"))
- return (void*) xglCmdWaitEvents;
- if (!strcmp(funcName, "xglCmdPipelineBarrier"))
- return (void*) xglCmdPipelineBarrier;
- if (!strcmp(funcName, "xglCmdBeginQuery"))
- return (void*) xglCmdBeginQuery;
- if (!strcmp(funcName, "xglCmdEndQuery"))
- return (void*) xglCmdEndQuery;
- if (!strcmp(funcName, "xglCmdResetQueryPool"))
- return (void*) xglCmdResetQueryPool;
- if (!strcmp(funcName, "xglCmdWriteTimestamp"))
- return (void*) xglCmdWriteTimestamp;
- if (!strcmp(funcName, "xglCmdInitAtomicCounters"))
- return (void*) xglCmdInitAtomicCounters;
- if (!strcmp(funcName, "xglCmdLoadAtomicCounters"))
- return (void*) xglCmdLoadAtomicCounters;
- if (!strcmp(funcName, "xglCmdSaveAtomicCounters"))
- return (void*) xglCmdSaveAtomicCounters;
- if (!strcmp(funcName, "xglCreateFramebuffer"))
- return (void*) xglCreateFramebuffer;
- if (!strcmp(funcName, "xglCreateRenderPass"))
- return (void*) xglCreateRenderPass;
- if (!strcmp(funcName, "xglCmdBeginRenderPass"))
- return (void*) xglCmdBeginRenderPass;
- if (!strcmp(funcName, "xglCmdEndRenderPass"))
- return (void*) xglCmdEndRenderPass;
- if (!strcmp(funcName, "xglDbgRegisterMsgCallback"))
- return (void*) xglDbgRegisterMsgCallback;
- if (!strcmp(funcName, "xglDbgUnregisterMsgCallback"))
- return (void*) xglDbgUnregisterMsgCallback;
- if (!strcmp(funcName, "xglCmdDbgMarkerBegin"))
- return (void*) xglCmdDbgMarkerBegin;
- if (!strcmp(funcName, "xglCmdDbgMarkerEnd"))
- return (void*) xglCmdDbgMarkerEnd;
+ if (!strcmp(funcName, "vkGetProcAddr"))
+ return (void *) vkGetProcAddr;
+ if (!strcmp(funcName, "vkCreateDevice"))
+ return (void*) vkCreateDevice;
+ if (!strcmp(funcName, "vkDestroyDevice"))
+ return (void*) vkDestroyDevice;
+ if (!strcmp(funcName, "vkGetExtensionSupport"))
+ return (void*) vkGetExtensionSupport;
+ if (!strcmp(funcName, "vkEnumerateLayers"))
+ return (void*) vkEnumerateLayers;
+ if (!strcmp(funcName, "vkQueueSubmit"))
+ return (void*) vkQueueSubmit;
+ if (!strcmp(funcName, "vkDestroyObject"))
+ return (void*) vkDestroyObject;
+ if (!strcmp(funcName, "vkCreateBufferView"))
+ return (void*) vkCreateBufferView;
+ if (!strcmp(funcName, "vkCreateImageView"))
+ return (void*) vkCreateImageView;
+ if (!strcmp(funcName, "vkCreateGraphicsPipeline"))
+ return (void*) vkCreateGraphicsPipeline;
+ if (!strcmp(funcName, "vkCreateGraphicsPipelineDerivative"))
+ return (void*) vkCreateGraphicsPipelineDerivative;
+ if (!strcmp(funcName, "vkCreateSampler"))
+ return (void*) vkCreateSampler;
+ if (!strcmp(funcName, "vkCreateDescriptorSetLayout"))
+ return (void*) vkCreateDescriptorSetLayout;
+ if (!strcmp(funcName, "vkCreateDescriptorSetLayoutChain"))
+ return (void*) vkCreateDescriptorSetLayoutChain;
+ if (!strcmp(funcName, "vkBeginDescriptorPoolUpdate"))
+ return (void*) vkBeginDescriptorPoolUpdate;
+ if (!strcmp(funcName, "vkEndDescriptorPoolUpdate"))
+ return (void*) vkEndDescriptorPoolUpdate;
+ if (!strcmp(funcName, "vkCreateDescriptorPool"))
+ return (void*) vkCreateDescriptorPool;
+ if (!strcmp(funcName, "vkResetDescriptorPool"))
+ return (void*) vkResetDescriptorPool;
+ if (!strcmp(funcName, "vkAllocDescriptorSets"))
+ return (void*) vkAllocDescriptorSets;
+ if (!strcmp(funcName, "vkClearDescriptorSets"))
+ return (void*) vkClearDescriptorSets;
+ if (!strcmp(funcName, "vkUpdateDescriptors"))
+ return (void*) vkUpdateDescriptors;
+ if (!strcmp(funcName, "vkCreateDynamicViewportState"))
+ return (void*) vkCreateDynamicViewportState;
+ if (!strcmp(funcName, "vkCreateDynamicRasterState"))
+ return (void*) vkCreateDynamicRasterState;
+ if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
+ return (void*) vkCreateDynamicColorBlendState;
+ if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
+ return (void*) vkCreateDynamicDepthStencilState;
+ if (!strcmp(funcName, "vkCreateCommandBuffer"))
+ return (void*) vkCreateCommandBuffer;
+ if (!strcmp(funcName, "vkBeginCommandBuffer"))
+ return (void*) vkBeginCommandBuffer;
+ if (!strcmp(funcName, "vkEndCommandBuffer"))
+ return (void*) vkEndCommandBuffer;
+ if (!strcmp(funcName, "vkResetCommandBuffer"))
+ return (void*) vkResetCommandBuffer;
+ if (!strcmp(funcName, "vkCmdBindPipeline"))
+ return (void*) vkCmdBindPipeline;
+ if (!strcmp(funcName, "vkCmdBindDynamicStateObject"))
+ return (void*) vkCmdBindDynamicStateObject;
+ if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
+ return (void*) vkCmdBindDescriptorSets;
+ if (!strcmp(funcName, "vkCmdBindVertexBuffer"))
+ return (void*) vkCmdBindVertexBuffer;
+ if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
+ return (void*) vkCmdBindIndexBuffer;
+ if (!strcmp(funcName, "vkCmdDraw"))
+ return (void*) vkCmdDraw;
+ if (!strcmp(funcName, "vkCmdDrawIndexed"))
+ return (void*) vkCmdDrawIndexed;
+ if (!strcmp(funcName, "vkCmdDrawIndirect"))
+ return (void*) vkCmdDrawIndirect;
+ if (!strcmp(funcName, "vkCmdDrawIndexedIndirect"))
+ return (void*) vkCmdDrawIndexedIndirect;
+ if (!strcmp(funcName, "vkCmdDispatch"))
+ return (void*) vkCmdDispatch;
+ if (!strcmp(funcName, "vkCmdDispatchIndirect"))
+ return (void*) vkCmdDispatchIndirect;
+ if (!strcmp(funcName, "vkCmdCopyBuffer"))
+ return (void*) vkCmdCopyBuffer;
+ if (!strcmp(funcName, "vkCmdCopyImage"))
+ return (void*) vkCmdCopyImage;
+ if (!strcmp(funcName, "vkCmdCopyBufferToImage"))
+ return (void*) vkCmdCopyBufferToImage;
+ if (!strcmp(funcName, "vkCmdCopyImageToBuffer"))
+ return (void*) vkCmdCopyImageToBuffer;
+ if (!strcmp(funcName, "vkCmdCloneImageData"))
+ return (void*) vkCmdCloneImageData;
+ if (!strcmp(funcName, "vkCmdUpdateBuffer"))
+ return (void*) vkCmdUpdateBuffer;
+ if (!strcmp(funcName, "vkCmdFillBuffer"))
+ return (void*) vkCmdFillBuffer;
+ if (!strcmp(funcName, "vkCmdClearColorImage"))
+ return (void*) vkCmdClearColorImage;
+ if (!strcmp(funcName, "vkCmdClearDepthStencil"))
+ return (void*) vkCmdClearDepthStencil;
+ if (!strcmp(funcName, "vkCmdResolveImage"))
+ return (void*) vkCmdResolveImage;
+ if (!strcmp(funcName, "vkCmdSetEvent"))
+ return (void*) vkCmdSetEvent;
+ if (!strcmp(funcName, "vkCmdResetEvent"))
+ return (void*) vkCmdResetEvent;
+ if (!strcmp(funcName, "vkCmdWaitEvents"))
+ return (void*) vkCmdWaitEvents;
+ if (!strcmp(funcName, "vkCmdPipelineBarrier"))
+ return (void*) vkCmdPipelineBarrier;
+ if (!strcmp(funcName, "vkCmdBeginQuery"))
+ return (void*) vkCmdBeginQuery;
+ if (!strcmp(funcName, "vkCmdEndQuery"))
+ return (void*) vkCmdEndQuery;
+ if (!strcmp(funcName, "vkCmdResetQueryPool"))
+ return (void*) vkCmdResetQueryPool;
+ if (!strcmp(funcName, "vkCmdWriteTimestamp"))
+ return (void*) vkCmdWriteTimestamp;
+ if (!strcmp(funcName, "vkCmdInitAtomicCounters"))
+ return (void*) vkCmdInitAtomicCounters;
+ if (!strcmp(funcName, "vkCmdLoadAtomicCounters"))
+ return (void*) vkCmdLoadAtomicCounters;
+ if (!strcmp(funcName, "vkCmdSaveAtomicCounters"))
+ return (void*) vkCmdSaveAtomicCounters;
+ if (!strcmp(funcName, "vkCreateFramebuffer"))
+ return (void*) vkCreateFramebuffer;
+ if (!strcmp(funcName, "vkCreateRenderPass"))
+ return (void*) vkCreateRenderPass;
+ if (!strcmp(funcName, "vkCmdBeginRenderPass"))
+ return (void*) vkCmdBeginRenderPass;
+ if (!strcmp(funcName, "vkCmdEndRenderPass"))
+ return (void*) vkCmdEndRenderPass;
+ if (!strcmp(funcName, "vkDbgRegisterMsgCallback"))
+ return (void*) vkDbgRegisterMsgCallback;
+ if (!strcmp(funcName, "vkDbgUnregisterMsgCallback"))
+ return (void*) vkDbgUnregisterMsgCallback;
+ if (!strcmp(funcName, "vkCmdDbgMarkerBegin"))
+ return (void*) vkCmdDbgMarkerBegin;
+ if (!strcmp(funcName, "vkCmdDbgMarkerEnd"))
+ return (void*) vkCmdDbgMarkerEnd;
if (!strcmp("drawStateDumpDotFile", funcName))
return (void*) drawStateDumpDotFile;
if (!strcmp("drawStateDumpCommandBufferDotFile", funcName))
@@ -2901,6 +2897,6 @@
else {
if (gpuw->pGPA == NULL)
return NULL;
- return gpuw->pGPA((XGL_PHYSICAL_GPU)gpuw->nextObject, funcName);
+ return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName);
}
}
diff --git a/layers/draw_state.h b/layers/draw_state.h
index d2d7650..0bf33c4 100644
--- a/layers/draw_state.h
+++ b/layers/draw_state.h
@@ -1,5 +1,5 @@
/*
- * XGL
+ * Vulkan
*
* Copyright (C) 2014 LunarG, Inc.
*
@@ -21,7 +21,7 @@
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
-#include "xglLayer.h"
+#include "vkLayer.h"
#include <vector>
using namespace std;
@@ -39,10 +39,10 @@
DRAWSTATE_UPDATE_WITHOUT_BEGIN, // Attempt to update descriptors w/o calling BeginDescriptorPoolUpdate
DRAWSTATE_INVALID_PIPELINE, // Invalid Pipeline referenced
DRAWSTATE_INVALID_CMD_BUFFER, // Invalid CmdBuffer referenced
- DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, // binding in xglCmdBindVertexData() too large for PSO's pVertexBindingDescriptions array
+ DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, // binding in vkCmdBindVertexData() too large for PSO's pVertexBindingDescriptions array
DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, // Invalid dyn state object
DRAWSTATE_MISSING_DOT_PROGRAM, // No "dot" program in order to generate png image
- DRAWSTATE_BINDING_DS_NO_END_UPDATE, // DS bound to CmdBuffer w/o call to xglEndDescriptorSetUpdate())
+ DRAWSTATE_BINDING_DS_NO_END_UPDATE, // DS bound to CmdBuffer w/o call to vkEndDescriptorSetUpdate())
DRAWSTATE_NO_DS_POOL, // No DS Pool is available
DRAWSTATE_OUT_OF_MEMORY, // malloc failed
DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, // Type in layout vs. update are not the same
@@ -65,84 +65,84 @@
typedef struct _SHADER_DS_MAPPING {
uint32_t slotCount;
- XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pShaderMappingSlot;
+ VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pShaderMappingSlot;
} SHADER_DS_MAPPING;
typedef struct _GENERIC_HEADER {
- XGL_STRUCTURE_TYPE sType;
+ VK_STRUCTURE_TYPE sType;
const void* pNext;
} GENERIC_HEADER;
typedef struct _PIPELINE_NODE {
- XGL_PIPELINE pipeline;
+ VK_PIPELINE pipeline;
- XGL_GRAPHICS_PIPELINE_CREATE_INFO graphicsPipelineCI;
- XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO vertexInputCI;
- XGL_PIPELINE_IA_STATE_CREATE_INFO iaStateCI;
- XGL_PIPELINE_TESS_STATE_CREATE_INFO tessStateCI;
- XGL_PIPELINE_VP_STATE_CREATE_INFO vpStateCI;
- XGL_PIPELINE_RS_STATE_CREATE_INFO rsStateCI;
- XGL_PIPELINE_MS_STATE_CREATE_INFO msStateCI;
- XGL_PIPELINE_CB_STATE_CREATE_INFO cbStateCI;
- XGL_PIPELINE_DS_STATE_CREATE_INFO dsStateCI;
- XGL_PIPELINE_SHADER_STAGE_CREATE_INFO vsCI;
- XGL_PIPELINE_SHADER_STAGE_CREATE_INFO tcsCI;
- XGL_PIPELINE_SHADER_STAGE_CREATE_INFO tesCI;
- XGL_PIPELINE_SHADER_STAGE_CREATE_INFO gsCI;
- XGL_PIPELINE_SHADER_STAGE_CREATE_INFO fsCI;
- // Compute shader is include in XGL_COMPUTE_PIPELINE_CREATE_INFO
- XGL_COMPUTE_PIPELINE_CREATE_INFO computePipelineCI;
+ VK_GRAPHICS_PIPELINE_CREATE_INFO graphicsPipelineCI;
+ VK_PIPELINE_VERTEX_INPUT_CREATE_INFO vertexInputCI;
+ VK_PIPELINE_IA_STATE_CREATE_INFO iaStateCI;
+ VK_PIPELINE_TESS_STATE_CREATE_INFO tessStateCI;
+ VK_PIPELINE_VP_STATE_CREATE_INFO vpStateCI;
+ VK_PIPELINE_RS_STATE_CREATE_INFO rsStateCI;
+ VK_PIPELINE_MS_STATE_CREATE_INFO msStateCI;
+ VK_PIPELINE_CB_STATE_CREATE_INFO cbStateCI;
+ VK_PIPELINE_DS_STATE_CREATE_INFO dsStateCI;
+ VK_PIPELINE_SHADER_STAGE_CREATE_INFO vsCI;
+ VK_PIPELINE_SHADER_STAGE_CREATE_INFO tcsCI;
+ VK_PIPELINE_SHADER_STAGE_CREATE_INFO tesCI;
+ VK_PIPELINE_SHADER_STAGE_CREATE_INFO gsCI;
+ VK_PIPELINE_SHADER_STAGE_CREATE_INFO fsCI;
+ // Compute shader is include in VK_COMPUTE_PIPELINE_CREATE_INFO
+ VK_COMPUTE_PIPELINE_CREATE_INFO computePipelineCI;
- XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateTree; // Ptr to shadow of data in create tree
+ VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateTree; // Ptr to shadow of data in create tree
// Vtx input info (if any)
uint32_t vtxBindingCount; // number of bindings
- XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pVertexBindingDescriptions;
+ VK_VERTEX_INPUT_BINDING_DESCRIPTION* pVertexBindingDescriptions;
uint32_t vtxAttributeCount; // number of attributes
- XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions;
+ VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions;
uint32_t attachmentCount; // number of CB attachments
- XGL_PIPELINE_CB_ATTACHMENT_STATE* pAttachments;
+ VK_PIPELINE_CB_ATTACHMENT_STATE* pAttachments;
} PIPELINE_NODE;
typedef struct _SAMPLER_NODE {
- XGL_SAMPLER sampler;
- XGL_SAMPLER_CREATE_INFO createInfo;
+ VK_SAMPLER sampler;
+ VK_SAMPLER_CREATE_INFO createInfo;
} SAMPLER_NODE;
typedef struct _IMAGE_NODE {
- XGL_IMAGE_VIEW image;
- XGL_IMAGE_VIEW_CREATE_INFO createInfo;
- XGL_IMAGE_VIEW_ATTACH_INFO attachInfo;
+ VK_IMAGE_VIEW image;
+ VK_IMAGE_VIEW_CREATE_INFO createInfo;
+ VK_IMAGE_VIEW_ATTACH_INFO attachInfo;
} IMAGE_NODE;
typedef struct _BUFFER_NODE {
- XGL_BUFFER_VIEW buffer;
- XGL_BUFFER_VIEW_CREATE_INFO createInfo;
- XGL_BUFFER_VIEW_ATTACH_INFO attachInfo;
+ VK_BUFFER_VIEW buffer;
+ VK_BUFFER_VIEW_CREATE_INFO createInfo;
+ VK_BUFFER_VIEW_ATTACH_INFO attachInfo;
} BUFFER_NODE;
typedef struct _DYNAMIC_STATE_NODE {
- XGL_DYNAMIC_STATE_OBJECT stateObj;
+ VK_DYNAMIC_STATE_OBJECT stateObj;
GENERIC_HEADER* pCreateInfo;
union {
- XGL_DYNAMIC_VP_STATE_CREATE_INFO vpci;
- XGL_DYNAMIC_RS_STATE_CREATE_INFO rsci;
- XGL_DYNAMIC_CB_STATE_CREATE_INFO cbci;
- XGL_DYNAMIC_DS_STATE_CREATE_INFO dsci;
+ VK_DYNAMIC_VP_STATE_CREATE_INFO vpci;
+ VK_DYNAMIC_RS_STATE_CREATE_INFO rsci;
+ VK_DYNAMIC_CB_STATE_CREATE_INFO cbci;
+ VK_DYNAMIC_DS_STATE_CREATE_INFO dsci;
} create_info;
} DYNAMIC_STATE_NODE;
// Descriptor Data structures
// Layout Node has the core layout data
typedef struct _LAYOUT_NODE {
- XGL_DESCRIPTOR_SET_LAYOUT layout;
- XGL_DESCRIPTOR_TYPE* pTypes; // Dynamic array that will be created to verify descriptor types
- XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO createInfo;
+ VK_DESCRIPTOR_SET_LAYOUT layout;
+ VK_DESCRIPTOR_TYPE* pTypes; // Dynamic array that will be created to verify descriptor types
+ VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO createInfo;
uint32_t startIndex; // 1st index of this layout
uint32_t endIndex; // last index of this layout
} LAYOUT_NODE;
typedef struct _SET_NODE {
- XGL_DESCRIPTOR_SET set;
- XGL_DESCRIPTOR_POOL pool;
- XGL_DESCRIPTOR_SET_USAGE setUsage;
+ VK_DESCRIPTOR_SET set;
+ VK_DESCRIPTOR_POOL pool;
+ VK_DESCRIPTOR_SET_USAGE setUsage;
// Head of LL of all Update structs for this set
GENERIC_HEADER* pUpdateStructs;
// Total num of descriptors in this set (count of its layout plus all prior layouts)
@@ -153,10 +153,10 @@
} SET_NODE;
typedef struct _POOL_NODE {
- XGL_DESCRIPTOR_POOL pool;
- XGL_DESCRIPTOR_POOL_USAGE poolUsage;
+ VK_DESCRIPTOR_POOL pool;
+ VK_DESCRIPTOR_POOL_USAGE poolUsage;
uint32_t maxSets;
- XGL_DESCRIPTOR_POOL_CREATE_INFO createInfo;
+ VK_DESCRIPTOR_POOL_CREATE_INFO createInfo;
bool32_t updateActive; // Track if Pool is in an update block
SET_NODE* pSets; // Head of LL of sets for this Pool
} POOL_NODE;
@@ -218,10 +218,10 @@
} CB_STATE;
// Cmd Buffer Wrapper Struct
typedef struct _GLOBAL_CB_NODE {
- XGL_CMD_BUFFER cmdBuffer;
+ VK_CMD_BUFFER cmdBuffer;
uint32_t queueNodeIndex;
- XGL_FLAGS flags;
- XGL_FENCE fence; // fence tracking this cmd buffer
+ VK_FLAGS flags;
+ VK_FENCE fence; // fence tracking this cmd buffer
uint64_t numCmds; // number of cmds in this CB
uint64_t drawCount[NUM_DRAW_TYPES]; // Count of each type of draw in this CB
CB_STATE state; // Track if cmd buffer update status
@@ -229,12 +229,12 @@
// Currently storing "lastBound" objects on per-CB basis
// long-term may want to create caches of "lastBound" states and could have
// each individual CMD_NODE referencing its own "lastBound" state
- XGL_PIPELINE lastBoundPipeline;
+ VK_PIPELINE lastBoundPipeline;
uint32_t lastVtxBinding;
- DYNAMIC_STATE_NODE* lastBoundDynamicState[XGL_NUM_STATE_BIND_POINT];
- XGL_DESCRIPTOR_SET lastBoundDescriptorSet;
- XGL_RENDER_PASS activeRenderPass;
- XGL_FRAMEBUFFER framebuffer;
+ DYNAMIC_STATE_NODE* lastBoundDynamicState[VK_NUM_STATE_BIND_POINT];
+ VK_DESCRIPTOR_SET lastBoundDescriptorSet;
+ VK_RENDER_PASS activeRenderPass;
+ VK_FRAMEBUFFER framebuffer;
} GLOBAL_CB_NODE;
//prototypes for extension functions
diff --git a/layers/glave_snapshot.c b/layers/glave_snapshot.c
index e757f2b..12caf3c 100644
--- a/layers/glave_snapshot.c
+++ b/layers/glave_snapshot.c
@@ -27,13 +27,13 @@
#include <string.h>
#include "loader_platform.h"
#include "glave_snapshot.h"
-#include "xgl_struct_string_helper.h"
+#include "vk_struct_string_helper.h"
#define LAYER_NAME_STR "GlaveSnapshot"
#define LAYER_ABBREV_STR "GLVSnap"
-static XGL_LAYER_DISPATCH_TABLE nextTable;
-static XGL_BASE_LAYER_OBJECT *pCurObj;
+static VK_LAYER_DISPATCH_TABLE nextTable;
+static VK_BASE_LAYER_OBJECT *pCurObj;
// The following is #included again to catch certain OS-specific functions being used:
#include "loader_platform.h"
@@ -62,15 +62,15 @@
memcpy(*ppDest, pSrc, size);
}
-XGL_DEVICE_CREATE_INFO* glv_deepcopy_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pSrcCreateInfo)
+VK_DEVICE_CREATE_INFO* glv_deepcopy_VK_DEVICE_CREATE_INFO(const VK_DEVICE_CREATE_INFO* pSrcCreateInfo)
{
- XGL_DEVICE_CREATE_INFO* pDestCreateInfo;
+ VK_DEVICE_CREATE_INFO* pDestCreateInfo;
- // NOTE: partially duplicated code from add_XGL_DEVICE_CREATE_INFO_to_packet(...)
+ // NOTE: partially duplicated code from add_VK_DEVICE_CREATE_INFO_to_packet(...)
{
uint32_t i;
- glv_vk_malloc_and_copy((void**)&pDestCreateInfo, sizeof(XGL_DEVICE_CREATE_INFO), pSrcCreateInfo);
- glv_vk_malloc_and_copy((void**)&pDestCreateInfo->pRequestedQueues, pSrcCreateInfo->queueRecordCount*sizeof(XGL_DEVICE_QUEUE_CREATE_INFO), pSrcCreateInfo->pRequestedQueues);
+ glv_vk_malloc_and_copy((void**)&pDestCreateInfo, sizeof(VK_DEVICE_CREATE_INFO), pSrcCreateInfo);
+ glv_vk_malloc_and_copy((void**)&pDestCreateInfo->pRequestedQueues, pSrcCreateInfo->queueRecordCount*sizeof(VK_DEVICE_QUEUE_CREATE_INFO), pSrcCreateInfo->pRequestedQueues);
if (pSrcCreateInfo->extensionCount > 0)
{
@@ -80,29 +80,29 @@
glv_vk_malloc_and_copy((void**)&pDestCreateInfo->ppEnabledExtensionNames[i], strlen(pSrcCreateInfo->ppEnabledExtensionNames[i]) + 1, pSrcCreateInfo->ppEnabledExtensionNames[i]);
}
}
- XGL_LAYER_CREATE_INFO *pSrcNext = ( XGL_LAYER_CREATE_INFO *) pSrcCreateInfo->pNext;
- XGL_LAYER_CREATE_INFO **ppDstNext = ( XGL_LAYER_CREATE_INFO **) &pDestCreateInfo->pNext;
+ VK_LAYER_CREATE_INFO *pSrcNext = ( VK_LAYER_CREATE_INFO *) pSrcCreateInfo->pNext;
+ VK_LAYER_CREATE_INFO **ppDstNext = ( VK_LAYER_CREATE_INFO **) &pDestCreateInfo->pNext;
while (pSrcNext != NULL)
{
- if ((pSrcNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pSrcNext->layerCount > 0)
+ if ((pSrcNext->sType == VK_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pSrcNext->layerCount > 0)
{
- glv_vk_malloc_and_copy((void**)ppDstNext, sizeof(XGL_LAYER_CREATE_INFO), pSrcNext);
+ glv_vk_malloc_and_copy((void**)ppDstNext, sizeof(VK_LAYER_CREATE_INFO), pSrcNext);
glv_vk_malloc_and_copy((void**)&(*ppDstNext)->ppActiveLayerNames, pSrcNext->layerCount * sizeof(char*), pSrcNext->ppActiveLayerNames);
for (i = 0; i < pSrcNext->layerCount; i++)
{
glv_vk_malloc_and_copy((void**)&(*ppDstNext)->ppActiveLayerNames[i], strlen(pSrcNext->ppActiveLayerNames[i]) + 1, pSrcNext->ppActiveLayerNames[i]);
}
- ppDstNext = (XGL_LAYER_CREATE_INFO**) &(*ppDstNext)->pNext;
+ ppDstNext = (VK_LAYER_CREATE_INFO**) &(*ppDstNext)->pNext;
}
- pSrcNext = (XGL_LAYER_CREATE_INFO*) pSrcNext->pNext;
+ pSrcNext = (VK_LAYER_CREATE_INFO*) pSrcNext->pNext;
}
}
return pDestCreateInfo;
}
-void glv_deepfree_xgl_device_create_info(XGL_DEVICE_CREATE_INFO* pCreateInfo)
+void glv_deepfree_VK_DEVICE_CREATE_INFO(VK_DEVICE_CREATE_INFO* pCreateInfo)
{
uint32_t i;
if (pCreateInfo->pRequestedQueues != NULL)
@@ -119,11 +119,11 @@
free((void*)pCreateInfo->ppEnabledExtensionNames);
}
- XGL_LAYER_CREATE_INFO *pSrcNext = (XGL_LAYER_CREATE_INFO*)pCreateInfo->pNext;
+ VK_LAYER_CREATE_INFO *pSrcNext = (VK_LAYER_CREATE_INFO*)pCreateInfo->pNext;
while (pSrcNext != NULL)
{
- XGL_LAYER_CREATE_INFO* pTmp = (XGL_LAYER_CREATE_INFO*)pSrcNext->pNext;
- if ((pSrcNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pSrcNext->layerCount > 0)
+ VK_LAYER_CREATE_INFO* pTmp = (VK_LAYER_CREATE_INFO*)pSrcNext->pNext;
+ if ((pSrcNext->sType == VK_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pSrcNext->layerCount > 0)
{
for (i = 0; i < pSrcNext->layerCount; i++)
{
@@ -139,21 +139,21 @@
free(pCreateInfo);
}
-void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice)
+void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
{
pDest->gpu = gpu;
- pDest->pCreateInfo = glv_deepcopy_xgl_device_create_info(pCreateInfo);
+ pDest->pCreateInfo = glv_deepcopy_VK_DEVICE_CREATE_INFO(pCreateInfo);
- pDest->pDevice = (XGL_DEVICE*)malloc(sizeof(XGL_DEVICE));
+ pDest->pDevice = (VK_DEVICE*)malloc(sizeof(VK_DEVICE));
*pDest->pDevice = *pDevice;
}
void glv_vk_snapshot_destroy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pSrc)
{
- memset(&pSrc->gpu, 0, sizeof(XGL_PHYSICAL_GPU));
+ memset(&pSrc->gpu, 0, sizeof(VK_PHYSICAL_GPU));
- glv_deepfree_xgl_device_create_info(pSrc->pCreateInfo);
+ glv_deepfree_VK_DEVICE_CREATE_INFO(pSrc->pCreateInfo);
pSrc->pCreateInfo = NULL;
free(pSrc->pDevice);
@@ -163,7 +163,7 @@
// add a new node to the global and object lists, then return it so the caller can populate the object information.
-static GLV_VK_SNAPSHOT_LL_NODE* snapshot_insert_object(GLV_VK_SNAPSHOT* pSnapshot, void* pObject, XGL_OBJECT_TYPE type)
+static GLV_VK_SNAPSHOT_LL_NODE* snapshot_insert_object(GLV_VK_SNAPSHOT* pSnapshot, void* pObject, VK_OBJECT_TYPE type)
{
// Create a new node
GLV_VK_SNAPSHOT_LL_NODE* pNewObjNode = (GLV_VK_SNAPSHOT_LL_NODE*)malloc(sizeof(GLV_VK_SNAPSHOT_LL_NODE));
@@ -188,7 +188,7 @@
}
// This is just a helper function to snapshot_remove_object(..). It is not intended for this to be called directly.
-static void snapshot_remove_obj_type(GLV_VK_SNAPSHOT* pSnapshot, void* pObj, XGL_OBJECT_TYPE objType) {
+static void snapshot_remove_obj_type(GLV_VK_SNAPSHOT* pSnapshot, void* pObj, VK_OBJECT_TYPE objType) {
GLV_VK_SNAPSHOT_LL_NODE *pTrav = pSnapshot->pObjectHead[objType];
GLV_VK_SNAPSHOT_LL_NODE *pPrev = pSnapshot->pObjectHead[objType];
while (pTrav) {
@@ -207,8 +207,8 @@
pTrav = pTrav->pNextObj;
}
char str[1024];
- sprintf(str, "OBJ INTERNAL ERROR : Obj %p was in global list but not in %s list", pObj, string_XGL_OBJECT_TYPE(objType));
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_INTERNAL_ERROR, LAYER_ABBREV_STR, str);
+ sprintf(str, "OBJ INTERNAL ERROR : Obj %p was in global list but not in %s list", pObj, string_VK_OBJECT_TYPE(objType));
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_INTERNAL_ERROR, LAYER_ABBREV_STR, str);
}
// Search global list to find object,
@@ -245,12 +245,12 @@
// Object not found.
char str[1024];
sprintf(str, "Object %p was not found in the created object list. It should be added as a deleted object.", pObject);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pObject, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pObject, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
return NULL;
}
// Add a new deleted object node to the list
-static void snapshot_insert_deleted_object(GLV_VK_SNAPSHOT* pSnapshot, void* pObject, XGL_OBJECT_TYPE type)
+static void snapshot_insert_deleted_object(GLV_VK_SNAPSHOT* pSnapshot, void* pObject, VK_OBJECT_TYPE type)
{
// Create a new node
GLV_VK_SNAPSHOT_DELETED_OBJ_NODE* pNewObjNode = (GLV_VK_SNAPSHOT_DELETED_OBJ_NODE*)malloc(sizeof(GLV_VK_SNAPSHOT_DELETED_OBJ_NODE));
@@ -267,9 +267,9 @@
}
// Note: the parameters after pSnapshot match the order of vkCreateDevice(..)
-static void snapshot_insert_device(GLV_VK_SNAPSHOT* pSnapshot, XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice)
+static void snapshot_insert_device(GLV_VK_SNAPSHOT* pSnapshot, VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
{
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(pSnapshot, *pDevice, XGL_OBJECT_TYPE_DEVICE);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(pSnapshot, *pDevice, VK_OBJECT_TYPE_DEVICE);
pNode->obj.pStruct = malloc(sizeof(GLV_VK_SNAPSHOT_DEVICE_NODE));
GLV_VK_SNAPSHOT_DEVICE_NODE* pDevNode = (GLV_VK_SNAPSHOT_DEVICE_NODE*)pNode->obj.pStruct;
@@ -283,7 +283,7 @@
pSnapshot->deviceCount++;
}
-static void snapshot_remove_device(GLV_VK_SNAPSHOT* pSnapshot, XGL_DEVICE device)
+static void snapshot_remove_device(GLV_VK_SNAPSHOT* pSnapshot, VK_DEVICE device)
{
GLV_VK_SNAPSHOT_LL_NODE* pFoundObject = snapshot_remove_object(pSnapshot, device);
@@ -327,11 +327,11 @@
// If the code got here, then the device wasn't in the devices list.
// That means we should add this device to the deleted items list.
- snapshot_insert_deleted_object(&s_delta, device, XGL_OBJECT_TYPE_DEVICE);
+ snapshot_insert_deleted_object(&s_delta, device, VK_OBJECT_TYPE_DEVICE);
}
// Traverse global list and return type for given object
-static XGL_OBJECT_TYPE ll_get_obj_type(XGL_OBJECT object) {
+static VK_OBJECT_TYPE ll_get_obj_type(VK_OBJECT object) {
GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pGlobalObjs;
while (pTrav) {
if (pTrav->obj.pVkObject == object)
@@ -340,11 +340,11 @@
}
char str[1024];
sprintf(str, "Attempting look-up on obj %p but it is NOT in the global list!", (void*)object);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, GLVSNAPSHOT_MISSING_OBJECT, LAYER_ABBREV_STR, str);
- return XGL_OBJECT_TYPE_UNKNOWN;
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, GLVSNAPSHOT_MISSING_OBJECT, LAYER_ABBREV_STR, str);
+ return VK_OBJECT_TYPE_UNKNOWN;
}
-static void ll_increment_use_count(void* pObj, XGL_OBJECT_TYPE objType) {
+static void ll_increment_use_count(void* pObj, VK_OBJECT_TYPE objType) {
GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[objType];
while (pTrav) {
if (pTrav->obj.pVkObject == pObj) {
@@ -359,15 +359,15 @@
// Instead, we need to make a list of referenced objects. When the delta is merged with a snapshot, we'll need
// to confirm that the referenced objects actually exist in the snapshot; otherwise I guess the merge should fail.
char str[1024];
- sprintf(str, "Unable to increment count for obj %p, will add to list as %s type and increment count", pObj, string_XGL_OBJECT_TYPE(objType));
- layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
+ sprintf(str, "Unable to increment count for obj %p, will add to list as %s type and increment count", pObj, string_VK_OBJECT_TYPE(objType));
+ layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
// ll_insert_obj(pObj, objType);
// ll_increment_use_count(pObj, objType);
}
// Set selected flag state for an object node
-static void set_status(void* pObj, XGL_OBJECT_TYPE objType, OBJECT_STATUS status_flag) {
+static void set_status(void* pObj, VK_OBJECT_TYPE objType, OBJECT_STATUS status_flag) {
if (pObj != NULL) {
GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[objType];
while (pTrav) {
@@ -380,24 +380,24 @@
// If we do not find it print an error
char str[1024];
- sprintf(str, "Unable to set status for non-existent object %p of %s type", pObj, string_XGL_OBJECT_TYPE(objType));
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
+ sprintf(str, "Unable to set status for non-existent object %p of %s type", pObj, string_VK_OBJECT_TYPE(objType));
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
}
}
// Track selected state for an object node
-static void track_object_status(void* pObj, XGL_STATE_BIND_POINT stateBindPoint) {
- GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[XGL_OBJECT_TYPE_CMD_BUFFER];
+static void track_object_status(void* pObj, VK_STATE_BIND_POINT stateBindPoint) {
+ GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[VK_OBJECT_TYPE_CMD_BUFFER];
while (pTrav) {
if (pTrav->obj.pVkObject == pObj) {
- if (stateBindPoint == XGL_STATE_BIND_VIEWPORT) {
+ if (stateBindPoint == VK_STATE_BIND_VIEWPORT) {
pTrav->obj.status |= OBJSTATUS_VIEWPORT_BOUND;
- } else if (stateBindPoint == XGL_STATE_BIND_RASTER) {
+ } else if (stateBindPoint == VK_STATE_BIND_RASTER) {
pTrav->obj.status |= OBJSTATUS_RASTER_BOUND;
- } else if (stateBindPoint == XGL_STATE_BIND_COLOR_BLEND) {
+ } else if (stateBindPoint == VK_STATE_BIND_COLOR_BLEND) {
pTrav->obj.status |= OBJSTATUS_COLOR_BLEND_BOUND;
- } else if (stateBindPoint == XGL_STATE_BIND_DEPTH_STENCIL) {
+ } else if (stateBindPoint == VK_STATE_BIND_DEPTH_STENCIL) {
pTrav->obj.status |= OBJSTATUS_DEPTH_STENCIL_BOUND;
}
return;
@@ -408,11 +408,11 @@
// If we do not find it print an error
char str[1024];
sprintf(str, "Unable to track status for non-existent Command Buffer object %p", pObj);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
}
// Reset selected flag state for an object node
-static void reset_status(void* pObj, XGL_OBJECT_TYPE objType, OBJECT_STATUS status_flag) {
+static void reset_status(void* pObj, VK_OBJECT_TYPE objType, OBJECT_STATUS status_flag) {
GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[objType];
while (pTrav) {
if (pTrav->obj.pVkObject == pObj) {
@@ -424,11 +424,11 @@
// If we do not find it print an error
char str[1024];
- sprintf(str, "Unable to reset status for non-existent object %p of %s type", pObj, string_XGL_OBJECT_TYPE(objType));
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
+ sprintf(str, "Unable to reset status for non-existent object %p of %s type", pObj, string_VK_OBJECT_TYPE(objType));
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pObj, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
}
-#include "xgl_dispatch_table_helper.h"
+#include "vk_dispatch_table_helper.h"
static void initGlaveSnapshot(void)
{
const char *strOpt;
@@ -436,7 +436,7 @@
getLayerOptionEnum(LAYER_NAME_STR "ReportLevel", (uint32_t *) &g_reportingLevel);
g_actionIsDefault = getLayerOptionEnum(LAYER_NAME_STR "DebugAction", (uint32_t *) &g_debugAction);
- if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
+ if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
{
strOpt = getLayerOption(LAYER_NAME_STR "LogFilename");
if (strOpt)
@@ -447,11 +447,11 @@
g_logFile = stdout;
}
- xglGetProcAddrType fpNextGPA;
+ vkGetProcAddrType fpNextGPA;
fpNextGPA = pCurObj->pGPA;
assert(fpNextGPA);
- layer_initialize_dispatch_table(&nextTable, fpNextGPA, (XGL_PHYSICAL_GPU) pCurObj->nextObject);
+ layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);
if (!objLockInitialized)
{
// TODO/TBD: Need to delete this mutex sometime. How???
@@ -463,49 +463,49 @@
//=============================================================================
// vulkan entrypoints
//=============================================================================
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateInstance(const XGL_INSTANCE_CREATE_INFO* pCreateInfo, XGL_INSTANCE* pInstance)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateInstance(const VK_INSTANCE_CREATE_INFO* pCreateInfo, VK_INSTANCE* pInstance)
{
- XGL_RESULT result = nextTable.CreateInstance(pCreateInfo, pInstance);
+ VK_RESULT result = nextTable.CreateInstance(pCreateInfo, pInstance);
loader_platform_thread_lock_mutex(&objLock);
- snapshot_insert_object(&s_delta, *pInstance, XGL_OBJECT_TYPE_INSTANCE);
+ snapshot_insert_object(&s_delta, *pInstance, VK_OBJECT_TYPE_INSTANCE);
loader_platform_thread_unlock_mutex(&objLock);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyInstance(XGL_INSTANCE instance)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyInstance(VK_INSTANCE instance)
{
- XGL_RESULT result = nextTable.DestroyInstance(instance);
+ VK_RESULT result = nextTable.DestroyInstance(instance);
loader_platform_thread_lock_mutex(&objLock);
snapshot_remove_object(&s_delta, (void*)instance);
loader_platform_thread_unlock_mutex(&objLock);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateGpus(XGL_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, XGL_PHYSICAL_GPU* pGpus)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateGpus(VK_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, VK_PHYSICAL_GPU* pGpus)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)instance, XGL_OBJECT_TYPE_INSTANCE);
+ ll_increment_use_count((void*)instance, VK_OBJECT_TYPE_INSTANCE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus);
+ VK_RESULT result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetGpuInfo(XGL_PHYSICAL_GPU gpu, XGL_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetGpuInfo(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
pCurObj = gpuw;
loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
- XGL_RESULT result = nextTable.GetGpuInfo((XGL_PHYSICAL_GPU)gpuw->nextObject, infoType, pDataSize, pData);
+ VK_RESULT result = nextTable.GetGpuInfo((VK_PHYSICAL_GPU)gpuw->nextObject, infoType, pDataSize, pData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
pCurObj = gpuw;
loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
- XGL_RESULT result = nextTable.CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
snapshot_insert_device(&s_delta, gpu, pCreateInfo, pDevice);
@@ -514,9 +514,9 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyDevice(XGL_DEVICE device)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device)
{
- XGL_RESULT result = nextTable.DestroyDevice(device);
+ VK_RESULT result = nextTable.DestroyDevice(device);
loader_platform_thread_lock_mutex(&objLock);
snapshot_remove_device(&s_delta, device);
loader_platform_thread_unlock_mutex(&objLock);
@@ -525,15 +525,15 @@
GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pGlobalObjs;
while (pTrav != NULL)
{
- if (pTrav->obj.objType == XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY)
+ if (pTrav->obj.objType == VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY)
{
GLV_VK_SNAPSHOT_LL_NODE *pDel = pTrav;
pTrav = pTrav->pNextGlobal;
snapshot_remove_object(&s_delta, (void*)(pDel->obj.pVkObject));
} else {
char str[1024];
- sprintf(str, "OBJ ERROR : %s object %p has not been destroyed (was used %lu times).", string_XGL_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pVkObject, pTrav->obj.numUses);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, device, 0, GLVSNAPSHOT_OBJECT_LEAK, LAYER_ABBREV_STR, str);
+ sprintf(str, "OBJ ERROR : %s object %p has not been destroyed (was used %lu times).", string_VK_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pVkObject, pTrav->obj.numUses);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, device, 0, GLVSNAPSHOT_OBJECT_LEAK, LAYER_ABBREV_STR, str);
pTrav = pTrav->pNextGlobal;
}
}
@@ -541,623 +541,623 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu, const char* pExtName)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)gpu, XGL_OBJECT_TYPE_PHYSICAL_GPU);
+ ll_increment_use_count((void*)gpu, VK_OBJECT_TYPE_PHYSICAL_GPU);
loader_platform_thread_unlock_mutex(&objLock);
pCurObj = gpuw;
loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
- XGL_RESULT result = nextTable.GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);
+ VK_RESULT result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
{
if (gpu != NULL) {
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)gpu, XGL_OBJECT_TYPE_PHYSICAL_GPU);
+ ll_increment_use_count((void*)gpu, VK_OBJECT_TYPE_PHYSICAL_GPU);
loader_platform_thread_unlock_mutex(&objLock);
pCurObj = gpuw;
loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
- XGL_RESULT result = nextTable.EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+ VK_RESULT result = nextTable.EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
return result;
} else {
if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
- return XGL_ERROR_INVALID_POINTER;
+ return VK_ERROR_INVALID_POINTER;
// This layer compatible with all GPUs
*pOutLayerCount = 1;
strncpy((char *) pOutLayers[0], LAYER_NAME_STR, maxStringSize);
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetDeviceQueue(XGL_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, XGL_QUEUE* pQueue)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetDeviceQueue(VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, VK_QUEUE* pQueue)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
+ VK_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit(VK_QUEUE queue, uint32_t cmdBufferCount, const VK_CMD_BUFFER* pCmdBuffers, VK_FENCE fence)
{
- set_status((void*)fence, XGL_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED);
- XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
+ set_status((void*)fence, VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED);
+ VK_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueWaitIdle(XGL_QUEUE queue)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitIdle(VK_QUEUE queue)
{
- XGL_RESULT result = nextTable.QueueWaitIdle(queue);
+ VK_RESULT result = nextTable.QueueWaitIdle(queue);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDeviceWaitIdle(XGL_DEVICE device)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDeviceWaitIdle(VK_DEVICE device)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.DeviceWaitIdle(device);
+ VK_RESULT result = nextTable.DeviceWaitIdle(device);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglAllocMemory(XGL_DEVICE device, const XGL_MEMORY_ALLOC_INFO* pAllocInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pMem, XGL_OBJECT_TYPE_GPU_MEMORY);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pMem, VK_OBJECT_TYPE_GPU_MEMORY);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglFreeMemory(XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkFreeMemory(VK_GPU_MEMORY mem)
{
- XGL_RESULT result = nextTable.FreeMemory(mem);
+ VK_RESULT result = nextTable.FreeMemory(mem);
loader_platform_thread_lock_mutex(&objLock);
snapshot_remove_object(&s_delta, (void*)mem);
loader_platform_thread_unlock_mutex(&objLock);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSetMemoryPriority(XGL_GPU_MEMORY mem, XGL_MEMORY_PRIORITY priority)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkSetMemoryPriority(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)mem, XGL_OBJECT_TYPE_GPU_MEMORY);
+ ll_increment_use_count((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.SetMemoryPriority(mem, priority);
+ VK_RESULT result = nextTable.SetMemoryPriority(mem, priority);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglMapMemory(XGL_GPU_MEMORY mem, XGL_FLAGS flags, void** ppData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkMapMemory(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)mem, XGL_OBJECT_TYPE_GPU_MEMORY);
+ ll_increment_use_count((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY);
loader_platform_thread_unlock_mutex(&objLock);
- set_status((void*)mem, XGL_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);
- XGL_RESULT result = nextTable.MapMemory(mem, flags, ppData);
+ set_status((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);
+ VK_RESULT result = nextTable.MapMemory(mem, flags, ppData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglUnmapMemory(XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkUnmapMemory(VK_GPU_MEMORY mem)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)mem, XGL_OBJECT_TYPE_GPU_MEMORY);
+ ll_increment_use_count((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY);
loader_platform_thread_unlock_mutex(&objLock);
- reset_status((void*)mem, XGL_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);
- XGL_RESULT result = nextTable.UnmapMemory(mem);
+ reset_status((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);
+ VK_RESULT result = nextTable.UnmapMemory(mem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglPinSystemMemory(XGL_DEVICE device, const void* pSysMem, size_t memSize, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkPinSystemMemory(VK_DEVICE device, const void* pSysMem, size_t memSize, VK_GPU_MEMORY* pMem)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem);
+ VK_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(XGL_PHYSICAL_GPU gpu0, XGL_PHYSICAL_GPU gpu1, XGL_GPU_COMPATIBILITY_INFO* pInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetMultiGpuCompatibility(VK_PHYSICAL_GPU gpu0, VK_PHYSICAL_GPU gpu1, VK_GPU_COMPATIBILITY_INFO* pInfo)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu0;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu0;
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)gpu0, XGL_OBJECT_TYPE_PHYSICAL_GPU);
+ ll_increment_use_count((void*)gpu0, VK_OBJECT_TYPE_PHYSICAL_GPU);
loader_platform_thread_unlock_mutex(&objLock);
pCurObj = gpuw;
loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
- XGL_RESULT result = nextTable.GetMultiGpuCompatibility((XGL_PHYSICAL_GPU)gpuw->nextObject, gpu1, pInfo);
+ VK_RESULT result = nextTable.GetMultiGpuCompatibility((VK_PHYSICAL_GPU)gpuw->nextObject, gpu1, pInfo);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenSharedMemory(XGL_DEVICE device, const XGL_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedMemory(VK_DEVICE device, const VK_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem);
+ VK_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenSharedSemaphore(XGL_DEVICE device, const XGL_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_SEMAPHORE* pSemaphore)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedSemaphore(VK_DEVICE device, const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, VK_SEMAPHORE* pSemaphore)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore);
+ VK_RESULT result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenPeerMemory(XGL_DEVICE device, const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerMemory(VK_DEVICE device, const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem);
+ VK_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenPeerImage(XGL_DEVICE device, const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerImage(VK_DEVICE device, const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem);
+ VK_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyObject(XGL_OBJECT object)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object)
{
- XGL_RESULT result = nextTable.DestroyObject(object);
+ VK_RESULT result = nextTable.DestroyObject(object);
loader_platform_thread_lock_mutex(&objLock);
snapshot_remove_object(&s_delta, (void*)object);
loader_platform_thread_unlock_mutex(&objLock);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetObjectInfo(XGL_BASE_OBJECT object, XGL_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetObjectInfo(VK_BASE_OBJECT object, VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
{
loader_platform_thread_lock_mutex(&objLock);
ll_increment_use_count((void*)object, ll_get_obj_type(object));
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData);
+ VK_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBindObjectMemory(XGL_OBJECT object, uint32_t allocationIdx, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemory(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_MEMORY mem, VK_GPU_SIZE offset)
{
loader_platform_thread_lock_mutex(&objLock);
ll_increment_use_count((void*)object, ll_get_obj_type(object));
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset);
+ VK_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset);
return result;
}
-XGL_LAYER_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)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemoryRange(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_SIZE rangeOffset, VK_GPU_SIZE rangeSize, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset)
{
loader_platform_thread_lock_mutex(&objLock);
ll_increment_use_count((void*)object, ll_get_obj_type(object));
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
+ VK_RESULT result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
return result;
}
-XGL_LAYER_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)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBindImageMemoryRange(VK_IMAGE image, uint32_t allocationIdx, const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)image, XGL_OBJECT_TYPE_IMAGE);
+ ll_increment_use_count((void*)image, VK_OBJECT_TYPE_IMAGE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.BindImageMemoryRange(image, allocationIdx, bindInfo, mem, memOffset);
+ VK_RESULT result = nextTable.BindImageMemoryRange(image, allocationIdx, bindInfo, mem, memOffset);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateFence(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFence(VK_DEVICE device, const VK_FENCE_CREATE_INFO* pCreateInfo, VK_FENCE* pFence)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pFence, XGL_OBJECT_TYPE_FENCE);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pFence, VK_OBJECT_TYPE_FENCE);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFenceStatus(XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFenceStatus(VK_FENCE fence)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)fence, XGL_OBJECT_TYPE_FENCE);
+ ll_increment_use_count((void*)fence, VK_OBJECT_TYPE_FENCE);
loader_platform_thread_unlock_mutex(&objLock);
// Warn if submitted_flag is not set
- XGL_RESULT result = nextTable.GetFenceStatus(fence);
+ VK_RESULT result = nextTable.GetFenceStatus(fence);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWaitForFences(XGL_DEVICE device, uint32_t fenceCount, const XGL_FENCE* pFences, bool32_t waitAll, uint64_t timeout)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWaitForFences(VK_DEVICE device, uint32_t fenceCount, const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
+ VK_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateSemaphore(XGL_DEVICE device, const XGL_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_SEMAPHORE* pSemaphore)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSemaphore(VK_DEVICE device, const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, VK_SEMAPHORE* pSemaphore)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSemaphore, XGL_OBJECT_TYPE_QUEUE_SEMAPHORE);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSemaphore, VK_OBJECT_TYPE_QUEUE_SEMAPHORE);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSignalSemaphore(XGL_QUEUE queue, XGL_SEMAPHORE semaphore)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSignalSemaphore(VK_QUEUE queue, VK_SEMAPHORE semaphore)
{
- XGL_RESULT result = nextTable.QueueSignalSemaphore(queue, semaphore);
+ VK_RESULT result = nextTable.QueueSignalSemaphore(queue, semaphore);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueWaitSemaphore(XGL_QUEUE queue, XGL_SEMAPHORE semaphore)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitSemaphore(VK_QUEUE queue, VK_SEMAPHORE semaphore)
{
- XGL_RESULT result = nextTable.QueueWaitSemaphore(queue, semaphore);
+ VK_RESULT result = nextTable.QueueWaitSemaphore(queue, semaphore);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateEvent(XGL_DEVICE device, const XGL_EVENT_CREATE_INFO* pCreateInfo, XGL_EVENT* pEvent)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateEvent(VK_DEVICE device, const VK_EVENT_CREATE_INFO* pCreateInfo, VK_EVENT* pEvent)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pEvent, XGL_OBJECT_TYPE_EVENT);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pEvent, VK_OBJECT_TYPE_EVENT);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetEventStatus(XGL_EVENT event)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetEventStatus(VK_EVENT event)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)event, XGL_OBJECT_TYPE_EVENT);
+ ll_increment_use_count((void*)event, VK_OBJECT_TYPE_EVENT);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.GetEventStatus(event);
+ VK_RESULT result = nextTable.GetEventStatus(event);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSetEvent(XGL_EVENT event)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkSetEvent(VK_EVENT event)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)event, XGL_OBJECT_TYPE_EVENT);
+ ll_increment_use_count((void*)event, VK_OBJECT_TYPE_EVENT);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.SetEvent(event);
+ VK_RESULT result = nextTable.SetEvent(event);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetEvent(XGL_EVENT event)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetEvent(VK_EVENT event)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)event, XGL_OBJECT_TYPE_EVENT);
+ ll_increment_use_count((void*)event, VK_OBJECT_TYPE_EVENT);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.ResetEvent(event);
+ VK_RESULT result = nextTable.ResetEvent(event);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateQueryPool(XGL_DEVICE device, const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo, XGL_QUERY_POOL* pQueryPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateQueryPool(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pQueryPool, XGL_OBJECT_TYPE_QUERY_POOL);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pQueryPool, VK_OBJECT_TYPE_QUERY_POOL);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetQueryPoolResults(XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetQueryPoolResults(VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)queryPool, XGL_OBJECT_TYPE_QUERY_POOL);
+ ll_increment_use_count((void*)queryPool, VK_OBJECT_TYPE_QUERY_POOL);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData);
+ VK_RESULT result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFormatInfo(XGL_DEVICE device, XGL_FORMAT format, XGL_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFormatInfo(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData);
+ VK_RESULT result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateBuffer(XGL_DEVICE device, const XGL_BUFFER_CREATE_INFO* pCreateInfo, XGL_BUFFER* pBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pBuffer, XGL_OBJECT_TYPE_BUFFER);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pBuffer, VK_OBJECT_TYPE_BUFFER);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateBufferView(XGL_DEVICE device, const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo, XGL_BUFFER_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, XGL_OBJECT_TYPE_BUFFER_VIEW);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, VK_OBJECT_TYPE_BUFFER_VIEW);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImage(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pImage, XGL_OBJECT_TYPE_IMAGE);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pImage, VK_OBJECT_TYPE_IMAGE);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetImageSubresourceInfo(XGL_IMAGE image, const XGL_IMAGE_SUBRESOURCE* pSubresource, XGL_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetImageSubresourceInfo(VK_IMAGE image, const VK_IMAGE_SUBRESOURCE* pSubresource, VK_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)image, XGL_OBJECT_TYPE_IMAGE);
+ ll_increment_use_count((void*)image, VK_OBJECT_TYPE_IMAGE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData);
+ VK_RESULT result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImageView(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, XGL_OBJECT_TYPE_IMAGE_VIEW);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, VK_OBJECT_TYPE_IMAGE_VIEW);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateColorAttachmentView(XGL_DEVICE device, const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, XGL_COLOR_ATTACHMENT_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, VK_COLOR_ATTACHMENT_VIEW* pView)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, XGL_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDepthStencilView(XGL_DEVICE device, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(VK_DEVICE device, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, VK_DEPTH_STENCIL_VIEW* pView)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, XGL_OBJECT_TYPE_DEPTH_STENCIL_VIEW);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateShader(XGL_DEVICE device, const XGL_SHADER_CREATE_INFO* pCreateInfo, XGL_SHADER* pShader)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateShader(VK_DEVICE device, const VK_SHADER_CREATE_INFO* pCreateInfo, VK_SHADER* pShader)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pShader, XGL_OBJECT_TYPE_SHADER);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pShader, VK_OBJECT_TYPE_SHADER);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pPipeline, XGL_OBJECT_TYPE_PIPELINE);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pPipeline, VK_OBJECT_TYPE_PIPELINE);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(VK_DEVICE device, const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pPipeline, XGL_OBJECT_TYPE_PIPELINE);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pPipeline, VK_OBJECT_TYPE_PIPELINE);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglStorePipeline(XGL_PIPELINE pipeline, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkStorePipeline(VK_PIPELINE pipeline, size_t* pDataSize, void* pData)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)pipeline, XGL_OBJECT_TYPE_PIPELINE);
+ ll_increment_use_count((void*)pipeline, VK_OBJECT_TYPE_PIPELINE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.StorePipeline(pipeline, pDataSize, pData);
+ VK_RESULT result = nextTable.StorePipeline(pipeline, pDataSize, pData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglLoadPipeline(XGL_DEVICE device, size_t dataSize, const void* pData, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkLoadPipeline(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE* pPipeline)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline);
+ VK_RESULT result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateSampler(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSampler, XGL_OBJECT_TYPE_SAMPLER);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSampler, VK_OBJECT_TYPE_SAMPLER);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSetLayout( XGL_DEVICE device, const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout( VK_DEVICE device, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_SET_LAYOUT* pSetLayout)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSetLayout, XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSetLayout, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginDescriptorPoolUpdate(XGL_DEVICE device, XGL_DESCRIPTOR_UPDATE_MODE updateMode)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(VK_DEVICE device, VK_DESCRIPTOR_UPDATE_MODE updateMode)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode);
+ VK_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEndDescriptorPoolUpdate(XGL_DEVICE device, XGL_CMD_BUFFER cmd)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEndDescriptorPoolUpdate(VK_DEVICE device, VK_CMD_BUFFER cmd)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd);
+ VK_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorPool(XGL_DEVICE device, XGL_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const XGL_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_POOL* pDescriptorPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_POOL* pDescriptorPool)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pDescriptorPool, XGL_OBJECT_TYPE_DESCRIPTOR_POOL);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pDescriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetDescriptorPool(XGL_DESCRIPTOR_POOL descriptorPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetDescriptorPool(VK_DESCRIPTOR_POOL descriptorPool)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)descriptorPool, XGL_OBJECT_TYPE_DESCRIPTOR_POOL);
+ ll_increment_use_count((void*)descriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.ResetDescriptorPool(descriptorPool);
+ VK_RESULT result = nextTable.ResetDescriptorPool(descriptorPool);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglAllocDescriptorSets(XGL_DESCRIPTOR_POOL descriptorPool, XGL_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts, XGL_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)descriptorPool, XGL_OBJECT_TYPE_DESCRIPTOR_POOL);
+ ll_increment_use_count((void*)descriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
+ if (result == VK_SUCCESS)
{
for (uint32_t i = 0; i < *pCount; i++) {
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, pDescriptorSets[i], XGL_OBJECT_TYPE_DESCRIPTOR_SET);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, pDescriptorSets[i], VK_OBJECT_TYPE_DESCRIPTOR_SET);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
@@ -1165,468 +1165,468 @@
return result;
}
-XGL_LAYER_EXPORT void XGLAPI xglClearDescriptorSets(XGL_DESCRIPTOR_POOL descriptorPool, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets)
+VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)descriptorPool, XGL_OBJECT_TYPE_DESCRIPTOR_POOL);
+ ll_increment_use_count((void*)descriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.ClearDescriptorSets(descriptorPool, count, pDescriptorSets);
}
-XGL_LAYER_EXPORT void XGLAPI xglUpdateDescriptors(XGL_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray)
+VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)descriptorSet, XGL_OBJECT_TYPE_DESCRIPTOR_SET);
+ ll_increment_use_count((void*)descriptorSet, VK_OBJECT_TYPE_DESCRIPTOR_SET);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.UpdateDescriptors(descriptorSet, updateCount, ppUpdateArray);
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicViewportState(XGL_DEVICE device, const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_VP_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_VP_STATE_OBJECT* pState)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, XGL_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicRasterState(XGL_DEVICE device, const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_RS_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_RS_STATE_OBJECT* pState)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, XGL_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicColorBlendState(XGL_DEVICE device, const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_CB_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_CB_STATE_OBJECT* pState)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, XGL_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState(XGL_DEVICE device, const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_DS_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_DS_STATE_OBJECT* pState)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, XGL_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateCommandBuffer(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pCmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pCmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginCommandBuffer(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
+ VK_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEndCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
- reset_status((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER, (OBJSTATUS_VIEWPORT_BOUND |
+ reset_status((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER, (OBJSTATUS_VIEWPORT_BOUND |
OBJSTATUS_RASTER_BOUND |
OBJSTATUS_COLOR_BLEND_BOUND |
OBJSTATUS_DEPTH_STENCIL_BOUND));
- XGL_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
+ VK_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
+ VK_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
return result;
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindPipeline(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline)
+VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDynamicStateObject(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
track_object_status((void*)cmdBuffer, stateBindPoint);
nextTable.CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDescriptorSets(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindVertexBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t binding)
+VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindIndexBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType)
+VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDraw(XGL_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
+VK_LAYER_EXPORT void VKAPI vkCmdDraw(VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndexed(XGL_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndexedIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDispatch(XGL_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdDispatch(cmdBuffer, x, y, z);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDispatchIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_COPY* pRegions)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_COPY* pRegions)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBufferToImage(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImageToBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCloneImageData(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout)
+VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdUpdateBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdFillBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, uint32_t data)
+VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearColorImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout, XGL_CLEAR_COLOR color, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, VK_CLEAR_COLOR color, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearDepthStencil(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdResolveImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects)
+VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdSetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent)
+VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdSetEvent(cmdBuffer, event, pipeEvent);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdResetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent)
+VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdResetEvent(cmdBuffer, event, pipeEvent);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdWaitEvents(XGL_CMD_BUFFER cmdBuffer, const XGL_EVENT_WAIT_INFO* pWaitInfo)
+VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVENT_WAIT_INFO* pWaitInfo)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdWaitEvents(cmdBuffer, pWaitInfo);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdPipelineBarrier(XGL_CMD_BUFFER cmdBuffer, const XGL_PIPELINE_BARRIER* pBarrier)
+VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const VK_PIPELINE_BARRIER* pBarrier)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdPipelineBarrier(cmdBuffer, pBarrier);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot, XGL_FLAGS flags)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdEndQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot)
+VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdEndQuery(cmdBuffer, queryPool, slot);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdResetQueryPool(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount)
+VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdWriteTimestamp(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset)
+VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMESTAMP_TYPE timestampType, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdInitAtomicCounters(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData);
}
-XGL_LAYER_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)
+VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER srcBuffer, VK_GPU_SIZE srcOffset)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset);
}
-XGL_LAYER_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)
+VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset);
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateFramebuffer(XGL_DEVICE device, const XGL_FRAMEBUFFER_CREATE_INFO* pCreateInfo, XGL_FRAMEBUFFER* pFramebuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(VK_DEVICE device, const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, VK_FRAMEBUFFER* pFramebuffer)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pFramebuffer, XGL_OBJECT_TYPE_FRAMEBUFFER);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pFramebuffer, VK_OBJECT_TYPE_FRAMEBUFFER);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateRenderPass(XGL_DEVICE device, const XGL_RENDER_PASS_CREATE_INFO* pCreateInfo, XGL_RENDER_PASS* pRenderPass)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, VK_RENDER_PASS* pRenderPass)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass);
- if (result == XGL_SUCCESS)
+ VK_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass);
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pRenderPass, XGL_OBJECT_TYPE_RENDER_PASS);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pRenderPass, VK_OBJECT_TYPE_RENDER_PASS);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
return result;
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginRenderPass(XGL_CMD_BUFFER cmdBuffer, const XGL_RENDER_PASS_BEGIN *pRenderPassBegin)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const VK_RENDER_PASS_BEGIN *pRenderPassBegin)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdEndRenderPass(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass)
+VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VK_CMD_BUFFER cmdBuffer, VK_RENDER_PASS renderPass)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdEndRenderPass(cmdBuffer, renderPass);
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetValidationLevel(XGL_DEVICE device, XGL_VALIDATION_LEVEL validationLevel)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetValidationLevel(VK_DEVICE device, VK_VALIDATION_LEVEL validationLevel)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.DbgSetValidationLevel(device, validationLevel);
+ VK_RESULT result = nextTable.DbgSetValidationLevel(device, validationLevel);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
{
// This layer intercepts callbacks
- XGL_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (XGL_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(XGL_LAYER_DBG_FUNCTION_NODE));
+ VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE));
if (!pNewDbgFuncNode)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;
pNewDbgFuncNode->pUserData = pUserData;
pNewDbgFuncNode->pNext = g_pDbgFunctionHead;
g_pDbgFunctionHead = pNewDbgFuncNode;
// force callbacks if DebugAction hasn't been set already other than initial value
if (g_actionIsDefault) {
- g_debugAction = XGL_DBG_LAYER_ACTION_CALLBACK;
- } XGL_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
+ g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK;
+ } VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
{
- XGL_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
- XGL_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;
+ VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
+ VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;
while (pTrav) {
if (pTrav->pfnMsgCallback == pfnMsgCallback) {
pPrev->pNext = pTrav->pNext;
@@ -1641,101 +1641,101 @@
if (g_pDbgFunctionHead == NULL)
{
if (g_actionIsDefault)
- g_debugAction = XGL_DBG_LAYER_ACTION_LOG_MSG;
+ g_debugAction = VK_DBG_LAYER_ACTION_LOG_MSG;
else
- g_debugAction &= ~XGL_DBG_LAYER_ACTION_CALLBACK;
+ g_debugAction &= ~VK_DBG_LAYER_ACTION_CALLBACK;
}
- XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
+ VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetMessageFilter(XGL_DEVICE device, int32_t msgCode, XGL_DBG_MSG_FILTER filter)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetMessageFilter(VK_DEVICE device, int32_t msgCode, VK_DBG_MSG_FILTER filter)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.DbgSetMessageFilter(device, msgCode, filter);
+ VK_RESULT result = nextTable.DbgSetMessageFilter(device, msgCode, filter);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetObjectTag(XGL_BASE_OBJECT object, size_t tagSize, const void* pTag)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetObjectTag(VK_BASE_OBJECT object, size_t tagSize, const void* pTag)
{
loader_platform_thread_lock_mutex(&objLock);
ll_increment_use_count((void*)object, ll_get_obj_type(object));
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.DbgSetObjectTag(object, tagSize, pTag);
+ VK_RESULT result = nextTable.DbgSetObjectTag(object, tagSize, pTag);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption(XGL_INSTANCE instance, XGL_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetGlobalOption(VK_INSTANCE instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData)
{
- XGL_RESULT result = nextTable.DbgSetGlobalOption(instance, dbgOption, dataSize, pData);
+ VK_RESULT result = nextTable.DbgSetGlobalOption(instance, dbgOption, dataSize, pData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetDeviceOption(XGL_DEVICE device, XGL_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetDeviceOption(VK_DEVICE device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData);
+ VK_RESULT result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData);
return result;
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDbgMarkerBegin(XGL_CMD_BUFFER cmdBuffer, const char* pMarker)
+VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VK_CMD_BUFFER cmdBuffer, const char* pMarker)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdDbgMarkerBegin(cmdBuffer, pMarker);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDbgMarkerEnd(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VK_CMD_BUFFER cmdBuffer)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
+ ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
loader_platform_thread_unlock_mutex(&objLock);
nextTable.CmdDbgMarkerEnd(cmdBuffer);
}
#if defined(__linux__) || defined(XCB_NVIDIA)
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11AssociateConnection(XGL_PHYSICAL_GPU gpu, const XGL_WSI_X11_CONNECTION_INFO* pConnectionInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11AssociateConnection(VK_PHYSICAL_GPU gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)gpu, XGL_OBJECT_TYPE_PHYSICAL_GPU);
+ ll_increment_use_count((void*)gpu, VK_OBJECT_TYPE_PHYSICAL_GPU);
loader_platform_thread_unlock_mutex(&objLock);
pCurObj = gpuw;
loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
- XGL_RESULT result = nextTable.WsiX11AssociateConnection((XGL_PHYSICAL_GPU)gpuw->nextObject, pConnectionInfo);
+ VK_RESULT result = nextTable.WsiX11AssociateConnection((VK_PHYSICAL_GPU)gpuw->nextObject, pConnectionInfo);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11GetMSC(XGL_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11GetMSC(VK_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc);
+ VK_RESULT result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11CreatePresentableImage(XGL_DEVICE device, const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11CreatePresentableImage(VK_DEVICE device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem)
{
loader_platform_thread_lock_mutex(&objLock);
- ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
+ ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
+ VK_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
- if (result == XGL_SUCCESS)
+ if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pImage, XGL_OBJECT_TYPE_IMAGE);
+ GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pImage, VK_OBJECT_TYPE_IMAGE);
pNode->obj.pStruct = NULL;
- GLV_VK_SNAPSHOT_LL_NODE* pMemNode = snapshot_insert_object(&s_delta, *pMem, XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);
+ GLV_VK_SNAPSHOT_LL_NODE* pMemNode = snapshot_insert_object(&s_delta, *pMem, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);
pMemNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
@@ -1743,9 +1743,9 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11QueuePresent(XGL_QUEUE queue, const XGL_WSI_X11_PRESENT_INFO* pPresentInfo, XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11QueuePresent(VK_QUEUE queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VK_FENCE fence)
{
- XGL_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
+ VK_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
return result;
}
@@ -1785,17 +1785,17 @@
char str[2048];
GLV_VK_SNAPSHOT_LL_NODE* pTrav = s_delta.pGlobalObjs;
sprintf(str, "==== DELTA SNAPSHOT contains %lu objects, %lu devices, and %lu deleted objects", s_delta.globalObjCount, s_delta.deviceCount, s_delta.deltaDeletedObjectCount);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
// print all objects
if (s_delta.globalObjCount > 0)
{
sprintf(str, "======== DELTA SNAPSHOT Created Objects:");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pTrav->obj.pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pTrav->obj.pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
while (pTrav != NULL)
{
- sprintf(str, "\t%s obj %p", string_XGL_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pVkObject);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pTrav->obj.pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+ sprintf(str, "\t%s obj %p", string_VK_OBJECT_TYPE(pTrav->obj.objType), pTrav->obj.pVkObject);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pTrav->obj.pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
pTrav = pTrav->pNextGlobal;
}
}
@@ -1805,13 +1805,13 @@
{
GLV_VK_SNAPSHOT_LL_NODE* pDeviceNode = s_delta.pDevices;
sprintf(str, "======== DELTA SNAPSHOT Devices:");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
while (pDeviceNode != NULL)
{
GLV_VK_SNAPSHOT_DEVICE_NODE* pDev = (GLV_VK_SNAPSHOT_DEVICE_NODE*)pDeviceNode->obj.pStruct;
- char * createInfoStr = xgl_print_xgl_device_create_info(pDev->params.pCreateInfo, "\t\t");
- sprintf(str, "\t%s obj %p:\n%s", string_XGL_OBJECT_TYPE(XGL_OBJECT_TYPE_DEVICE), pDeviceNode->obj.pVkObject, createInfoStr);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pDeviceNode->obj.pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+ char * createInfoStr = vk_print_vk_device_create_info(pDev->params.pCreateInfo, "\t\t");
+ sprintf(str, "\t%s obj %p:\n%s", string_VK_OBJECT_TYPE(VK_OBJECT_TYPE_DEVICE), pDeviceNode->obj.pVkObject, createInfoStr);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDeviceNode->obj.pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
pDeviceNode = pDeviceNode->pNextObj;
}
}
@@ -1821,11 +1821,11 @@
{
GLV_VK_SNAPSHOT_DELETED_OBJ_NODE* pDelObjNode = s_delta.pDeltaDeletedObjects;
sprintf(str, "======== DELTA SNAPSHOT Deleted Objects:");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
while (pDelObjNode != NULL)
{
- sprintf(str, " %s obj %p", string_XGL_OBJECT_TYPE(pDelObjNode->objType), pDelObjNode->pVkObject);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pDelObjNode->pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+ sprintf(str, " %s obj %p", string_VK_OBJECT_TYPE(pDelObjNode->objType), pDelObjNode->pVkObject);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDelObjNode->pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
pDelObjNode = pDelObjNode->pNextObj;
}
}
@@ -1852,23 +1852,23 @@
//=============================================================================
// Old Exported methods
//=============================================================================
-uint64_t glvSnapshotGetObjectCount(XGL_OBJECT_TYPE type)
+uint64_t glvSnapshotGetObjectCount(VK_OBJECT_TYPE type)
{
- uint64_t retVal = (type == XGL_OBJECT_TYPE_ANY) ? s_delta.globalObjCount : s_delta.numObjs[type];
+ uint64_t retVal = (type == VK_OBJECT_TYPE_ANY) ? s_delta.globalObjCount : s_delta.numObjs[type];
return retVal;
}
-XGL_RESULT glvSnapshotGetObjects(XGL_OBJECT_TYPE type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE *pObjNodeArray)
+VK_RESULT glvSnapshotGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE *pObjNodeArray)
{
// This bool flags if we're pulling all objs or just a single class of objs
- bool32_t bAllObjs = (type == XGL_OBJECT_TYPE_ANY);
+ bool32_t bAllObjs = (type == VK_OBJECT_TYPE_ANY);
// Check the count first thing
uint64_t maxObjCount = (bAllObjs) ? s_delta.globalObjCount : s_delta.numObjs[type];
if (objCount > maxObjCount) {
char str[1024];
- sprintf(str, "OBJ ERROR : Received objTrackGetObjects() request for %lu objs, but there are only %lu objs of type %s", objCount, maxObjCount, string_XGL_OBJECT_TYPE(type));
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, 0, 0, GLVSNAPSHOT_OBJCOUNT_MAX_EXCEEDED, LAYER_ABBREV_STR, str);
- return XGL_ERROR_INVALID_VALUE;
+ sprintf(str, "OBJ ERROR : Received objTrackGetObjects() request for %lu objs, but there are only %lu objs of type %s", objCount, maxObjCount, string_VK_OBJECT_TYPE(type));
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, 0, 0, GLVSNAPSHOT_OBJCOUNT_MAX_EXCEEDED, LAYER_ABBREV_STR, str);
+ return VK_ERROR_INVALID_VALUE;
}
GLV_VK_SNAPSHOT_LL_NODE* pTrav = (bAllObjs) ? s_delta.pGlobalObjs : s_delta.pObjectHead[type];
@@ -1876,14 +1876,14 @@
for (uint64_t i = 0; i < objCount; i++) {
if (!pTrav) {
char str[1024];
- sprintf(str, "OBJ INTERNAL ERROR : Ran out of %s objs! Should have %lu, but only copied %lu and not the requested %lu.", string_XGL_OBJECT_TYPE(type), maxObjCount, i, objCount);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, 0, 0, GLVSNAPSHOT_INTERNAL_ERROR, LAYER_ABBREV_STR, str);
- return XGL_ERROR_UNKNOWN;
+ sprintf(str, "OBJ INTERNAL ERROR : Ran out of %s objs! Should have %lu, but only copied %lu and not the requested %lu.", string_VK_OBJECT_TYPE(type), maxObjCount, i, objCount);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, 0, 0, GLVSNAPSHOT_INTERNAL_ERROR, LAYER_ABBREV_STR, str);
+ return VK_ERROR_UNKNOWN;
}
memcpy(&pObjNodeArray[i], pTrav, sizeof(GLV_VK_SNAPSHOT_OBJECT_NODE));
pTrav = (bAllObjs) ? pTrav->pNextGlobal : pTrav->pNextObj;
}
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
void glvSnapshotPrintObjects(void)
@@ -1891,10 +1891,10 @@
glvSnapshotPrintDelta();
}
-#include "xgl_generic_intercept_proc_helper.h"
-XGL_LAYER_EXPORT void* XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* funcName)
+#include "vk_generic_intercept_proc_helper.h"
+VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
void* addr;
if (gpu == NULL)
return NULL;
@@ -1927,7 +1927,7 @@
else {
if (gpuw->pGPA == NULL)
return NULL;
- return gpuw->pGPA((XGL_PHYSICAL_GPU)gpuw->nextObject, funcName);
+ return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName);
}
}
diff --git a/layers/glave_snapshot.h b/layers/glave_snapshot.h
index 8bd1b09..6e56b35 100644
--- a/layers/glave_snapshot.h
+++ b/layers/glave_snapshot.h
@@ -58,106 +58,106 @@
} OBJECT_STATUS;
// Object type enum
-typedef enum _XGL_OBJECT_TYPE
+typedef enum _VK_OBJECT_TYPE
{
- XGL_OBJECT_TYPE_UNKNOWN,
- XGL_OBJECT_TYPE_SAMPLER,
- XGL_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT,
- XGL_OBJECT_TYPE_DESCRIPTOR_SET,
- XGL_OBJECT_TYPE_DESCRIPTOR_POOL,
- XGL_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT,
- XGL_OBJECT_TYPE_IMAGE_VIEW,
- XGL_OBJECT_TYPE_QUEUE_SEMAPHORE,
- XGL_OBJECT_TYPE_SHADER,
- XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
- XGL_OBJECT_TYPE_BUFFER,
- XGL_OBJECT_TYPE_PIPELINE,
- XGL_OBJECT_TYPE_DEVICE,
- XGL_OBJECT_TYPE_QUERY_POOL,
- XGL_OBJECT_TYPE_EVENT,
- XGL_OBJECT_TYPE_QUEUE,
- XGL_OBJECT_TYPE_PHYSICAL_GPU,
- XGL_OBJECT_TYPE_RENDER_PASS,
- XGL_OBJECT_TYPE_FRAMEBUFFER,
- XGL_OBJECT_TYPE_IMAGE,
- XGL_OBJECT_TYPE_BUFFER_VIEW,
- XGL_OBJECT_TYPE_DEPTH_STENCIL_VIEW,
- XGL_OBJECT_TYPE_INSTANCE,
- XGL_OBJECT_TYPE_PIPELINE_DELTA,
- XGL_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT,
- XGL_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW,
- XGL_OBJECT_TYPE_GPU_MEMORY,
- XGL_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT,
- XGL_OBJECT_TYPE_FENCE,
- XGL_OBJECT_TYPE_CMD_BUFFER,
- XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY,
+ VK_OBJECT_TYPE_UNKNOWN,
+ VK_OBJECT_TYPE_SAMPLER,
+ VK_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT,
+ VK_OBJECT_TYPE_DESCRIPTOR_SET,
+ VK_OBJECT_TYPE_DESCRIPTOR_POOL,
+ VK_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT,
+ VK_OBJECT_TYPE_IMAGE_VIEW,
+ VK_OBJECT_TYPE_QUEUE_SEMAPHORE,
+ VK_OBJECT_TYPE_SHADER,
+ VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
+ VK_OBJECT_TYPE_BUFFER,
+ VK_OBJECT_TYPE_PIPELINE,
+ VK_OBJECT_TYPE_DEVICE,
+ VK_OBJECT_TYPE_QUERY_POOL,
+ VK_OBJECT_TYPE_EVENT,
+ VK_OBJECT_TYPE_QUEUE,
+ VK_OBJECT_TYPE_PHYSICAL_GPU,
+ VK_OBJECT_TYPE_RENDER_PASS,
+ VK_OBJECT_TYPE_FRAMEBUFFER,
+ VK_OBJECT_TYPE_IMAGE,
+ VK_OBJECT_TYPE_BUFFER_VIEW,
+ VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW,
+ VK_OBJECT_TYPE_INSTANCE,
+ VK_OBJECT_TYPE_PIPELINE_DELTA,
+ VK_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT,
+ VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW,
+ VK_OBJECT_TYPE_GPU_MEMORY,
+ VK_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT,
+ VK_OBJECT_TYPE_FENCE,
+ VK_OBJECT_TYPE_CMD_BUFFER,
+ VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY,
- XGL_NUM_OBJECT_TYPE,
- XGL_OBJECT_TYPE_ANY, // Allow global object list to be queried/retrieved
-} XGL_OBJECT_TYPE;
+ VK_NUM_OBJECT_TYPE,
+ VK_OBJECT_TYPE_ANY, // Allow global object list to be queried/retrieved
+} VK_OBJECT_TYPE;
-static const char* string_XGL_OBJECT_TYPE(XGL_OBJECT_TYPE type) {
+static const char* string_VK_OBJECT_TYPE(VK_OBJECT_TYPE type) {
switch (type)
{
- case XGL_OBJECT_TYPE_DEVICE:
+ case VK_OBJECT_TYPE_DEVICE:
return "DEVICE";
- case XGL_OBJECT_TYPE_PIPELINE:
+ case VK_OBJECT_TYPE_PIPELINE:
return "PIPELINE";
- case XGL_OBJECT_TYPE_FENCE:
+ case VK_OBJECT_TYPE_FENCE:
return "FENCE";
- case XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
+ case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
return "DESCRIPTOR_SET_LAYOUT";
- case XGL_OBJECT_TYPE_GPU_MEMORY:
+ case VK_OBJECT_TYPE_GPU_MEMORY:
return "GPU_MEMORY";
- case XGL_OBJECT_TYPE_QUEUE:
+ case VK_OBJECT_TYPE_QUEUE:
return "QUEUE";
- case XGL_OBJECT_TYPE_IMAGE:
+ case VK_OBJECT_TYPE_IMAGE:
return "IMAGE";
- case XGL_OBJECT_TYPE_CMD_BUFFER:
+ case VK_OBJECT_TYPE_CMD_BUFFER:
return "CMD_BUFFER";
- case XGL_OBJECT_TYPE_QUEUE_SEMAPHORE:
+ case VK_OBJECT_TYPE_QUEUE_SEMAPHORE:
return "QUEUE_SEMAPHORE";
- case XGL_OBJECT_TYPE_FRAMEBUFFER:
+ case VK_OBJECT_TYPE_FRAMEBUFFER:
return "FRAMEBUFFER";
- case XGL_OBJECT_TYPE_SAMPLER:
+ case VK_OBJECT_TYPE_SAMPLER:
return "SAMPLER";
- case XGL_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW:
+ case VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW:
return "COLOR_ATTACHMENT_VIEW";
- case XGL_OBJECT_TYPE_BUFFER_VIEW:
+ case VK_OBJECT_TYPE_BUFFER_VIEW:
return "BUFFER_VIEW";
- case XGL_OBJECT_TYPE_DESCRIPTOR_SET:
+ case VK_OBJECT_TYPE_DESCRIPTOR_SET:
return "DESCRIPTOR_SET";
- case XGL_OBJECT_TYPE_PHYSICAL_GPU:
+ case VK_OBJECT_TYPE_PHYSICAL_GPU:
return "PHYSICAL_GPU";
- case XGL_OBJECT_TYPE_IMAGE_VIEW:
+ case VK_OBJECT_TYPE_IMAGE_VIEW:
return "IMAGE_VIEW";
- case XGL_OBJECT_TYPE_BUFFER:
+ case VK_OBJECT_TYPE_BUFFER:
return "BUFFER";
- case XGL_OBJECT_TYPE_PIPELINE_DELTA:
+ case VK_OBJECT_TYPE_PIPELINE_DELTA:
return "PIPELINE_DELTA";
- case XGL_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT:
+ case VK_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT:
return "DYNAMIC_RS_STATE_OBJECT";
- case XGL_OBJECT_TYPE_EVENT:
+ case VK_OBJECT_TYPE_EVENT:
return "EVENT";
- case XGL_OBJECT_TYPE_DEPTH_STENCIL_VIEW:
+ case VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW:
return "DEPTH_STENCIL_VIEW";
- case XGL_OBJECT_TYPE_SHADER:
+ case VK_OBJECT_TYPE_SHADER:
return "SHADER";
- case XGL_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT:
+ case VK_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT:
return "DYNAMIC_DS_STATE_OBJECT";
- case XGL_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT:
+ case VK_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT:
return "DYNAMIC_VP_STATE_OBJECT";
- case XGL_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT:
+ case VK_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT:
return "DYNAMIC_CB_STATE_OBJECT";
- case XGL_OBJECT_TYPE_INSTANCE:
+ case VK_OBJECT_TYPE_INSTANCE:
return "INSTANCE";
- case XGL_OBJECT_TYPE_RENDER_PASS:
+ case VK_OBJECT_TYPE_RENDER_PASS:
return "RENDER_PASS";
- case XGL_OBJECT_TYPE_QUERY_POOL:
+ case VK_OBJECT_TYPE_QUERY_POOL:
return "QUERY_POOL";
- case XGL_OBJECT_TYPE_DESCRIPTOR_POOL:
+ case VK_OBJECT_TYPE_DESCRIPTOR_POOL:
return "DESCRIPTOR_POOL";
- case XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY:
+ case VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY:
return "PRESENTABLE_IMAGE_MEMORY";
default:
return "UNKNOWN";
@@ -173,13 +173,13 @@
typedef struct _GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS
{
- XGL_PHYSICAL_GPU gpu;
- XGL_DEVICE_CREATE_INFO* pCreateInfo;
- XGL_DEVICE* pDevice;
+ VK_PHYSICAL_GPU gpu;
+ VK_DEVICE_CREATE_INFO* pCreateInfo;
+ VK_DEVICE* pDevice;
} GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS;
-XGL_DEVICE_CREATE_INFO* glv_deepcopy_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pSrcCreateInfo);void glv_deepfree_xgl_device_create_info(XGL_DEVICE_CREATE_INFO* pCreateInfo);
-void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice);
+VK_DEVICE_CREATE_INFO* glv_deepcopy_xgl_device_create_info(const VK_DEVICE_CREATE_INFO* pSrcCreateInfo);void glv_deepfree_xgl_device_create_info(VK_DEVICE_CREATE_INFO* pCreateInfo);
+void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice);
void glv_vk_snapshot_destroy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pSrc);
//=============================================================================
@@ -189,16 +189,16 @@
// Node that stores information about an object
typedef struct _GLV_VK_SNAPSHOT_OBJECT_NODE {
void* pVkObject;
- XGL_OBJECT_TYPE objType;
+ VK_OBJECT_TYPE objType;
uint64_t numUses;
OBJECT_STATUS status;
void* pStruct; //< optionally points to a device-specific struct (ie, GLV_VK_SNAPSHOT_DEVICE_NODE)
} GLV_VK_SNAPSHOT_OBJECT_NODE;
-// Node that stores information about an XGL_DEVICE
+// Node that stores information about an VK_DEVICE
typedef struct _GLV_VK_SNAPSHOT_DEVICE_NODE {
// This object
- XGL_DEVICE device;
+ VK_DEVICE device;
// CreateDevice parameters
GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS params;
@@ -222,7 +222,7 @@
typedef struct _GLV_VK_SNAPSHOT_DELETED_OBJ_NODE {
struct _GLV_VK_SNAPSHOT_DELETED_OBJ_NODE* pNextObj;
void* pVkObject;
- XGL_OBJECT_TYPE objType;
+ VK_OBJECT_TYPE objType;
} GLV_VK_SNAPSHOT_DELETED_OBJ_NODE;
//=============================================================================
@@ -235,8 +235,8 @@
GLV_VK_SNAPSHOT_LL_NODE* pGlobalObjs;
// TEMPORARY: Keep track of all objects of each type
- uint64_t numObjs[XGL_NUM_OBJECT_TYPE];
- GLV_VK_SNAPSHOT_LL_NODE *pObjectHead[XGL_NUM_OBJECT_TYPE];
+ uint64_t numObjs[VK_NUM_OBJECT_TYPE];
+ GLV_VK_SNAPSHOT_LL_NODE *pObjectHead[VK_NUM_OBJECT_TYPE];
// List of created devices and [potentially] hierarchical tree of the objects on it.
// This is used to represent ownership of the objects
@@ -290,13 +290,13 @@
// merge a delta into a snapshot and return the updated snapshot
GLV_VK_SNAPSHOT glvSnapshotMerge(const GLV_VK_SNAPSHOT * const pDelta, const GLV_VK_SNAPSHOT * const pSnapshot);
-uint64_t glvSnapshotGetObjectCount(XGL_OBJECT_TYPE type);
-XGL_RESULT glvSnapshotGetObjects(XGL_OBJECT_TYPE type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE* pObjNodeArray);
+uint64_t glvSnapshotGetObjectCount(VK_OBJECT_TYPE type);
+VK_RESULT glvSnapshotGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE* pObjNodeArray);
void glvSnapshotPrintObjects(void);
// Func ptr typedefs
-typedef uint64_t (*GLVSNAPSHOT_GET_OBJECT_COUNT)(XGL_OBJECT_TYPE);
-typedef XGL_RESULT (*GLVSNAPSHOT_GET_OBJECTS)(XGL_OBJECT_TYPE, uint64_t, GLV_VK_SNAPSHOT_OBJECT_NODE*);
+typedef uint64_t (*GLVSNAPSHOT_GET_OBJECT_COUNT)(VK_OBJECT_TYPE);
+typedef VK_RESULT (*GLVSNAPSHOT_GET_OBJECTS)(VK_OBJECT_TYPE, uint64_t, GLV_VK_SNAPSHOT_OBJECT_NODE*);
typedef void (*GLVSNAPSHOT_PRINT_OBJECTS)(void);
typedef void (*GLVSNAPSHOT_START_TRACKING)(void);
typedef GLV_VK_SNAPSHOT (*GLVSNAPSHOT_GET_DELTA)(void);
diff --git a/layers/layers_config.cpp b/layers/layers_config.cpp
index 6992f06..134bf16 100644
--- a/layers/layers_config.cpp
+++ b/layers/layers_config.cpp
@@ -26,7 +26,7 @@
#include <string>
#include <map>
#include <string.h>
-#include <xglLayer.h>
+#include <vkLayer.h>
#include "loader_platform.h"
#include "layers_config.h"
// The following is #included again to catch certain OS-specific functions
@@ -56,24 +56,24 @@
static unsigned int convertStringEnumVal(const char *_enum)
{
// only handles single enum values
- if (!strcmp(_enum, "XGL_DBG_LAYER_ACTION_IGNORE"))
- return XGL_DBG_LAYER_ACTION_IGNORE;
- else if (!strcmp(_enum, "XGL_DBG_LAYER_ACTION_CALLBACK"))
- return XGL_DBG_LAYER_ACTION_CALLBACK;
- else if (!strcmp(_enum, "XGL_DBG_LAYER_ACTION_LOG_MSG"))
- return XGL_DBG_LAYER_ACTION_LOG_MSG;
- else if (!strcmp(_enum, "XGL_DBG_LAYER_ACTION_BREAK"))
- return XGL_DBG_LAYER_ACTION_BREAK;
- else if (!strcmp(_enum, "XGL_DBG_LAYER_LEVEL_INFO"))
- return XGL_DBG_LAYER_LEVEL_INFO;
- else if (!strcmp(_enum, "XGL_DBG_LAYER_LEVEL_WARN"))
- return XGL_DBG_LAYER_LEVEL_WARN;
- else if (!strcmp(_enum, "XGL_DBG_LAYER_LEVEL_PERF_WARN"))
- return XGL_DBG_LAYER_LEVEL_PERF_WARN;
- else if (!strcmp(_enum, "XGL_DBG_LAYER_LEVEL_ERROR"))
- return XGL_DBG_LAYER_LEVEL_ERROR;
- else if (!strcmp(_enum, "XGL_DBG_LAYER_LEVEL_NONE"))
- return XGL_DBG_LAYER_LEVEL_NONE;
+ if (!strcmp(_enum, "VK_DBG_LAYER_ACTION_IGNORE"))
+ return VK_DBG_LAYER_ACTION_IGNORE;
+ else if (!strcmp(_enum, "VK_DBG_LAYER_ACTION_CALLBACK"))
+ return VK_DBG_LAYER_ACTION_CALLBACK;
+ else if (!strcmp(_enum, "VK_DBG_LAYER_ACTION_LOG_MSG"))
+ return VK_DBG_LAYER_ACTION_LOG_MSG;
+ else if (!strcmp(_enum, "VK_DBG_LAYER_ACTION_BREAK"))
+ return VK_DBG_LAYER_ACTION_BREAK;
+ else if (!strcmp(_enum, "VK_DBG_LAYER_LEVEL_INFO"))
+ return VK_DBG_LAYER_LEVEL_INFO;
+ else if (!strcmp(_enum, "VK_DBG_LAYER_LEVEL_WARN"))
+ return VK_DBG_LAYER_LEVEL_WARN;
+ else if (!strcmp(_enum, "VK_DBG_LAYER_LEVEL_PERF_WARN"))
+ return VK_DBG_LAYER_LEVEL_PERF_WARN;
+ else if (!strcmp(_enum, "VK_DBG_LAYER_LEVEL_ERROR"))
+ return VK_DBG_LAYER_LEVEL_ERROR;
+ else if (!strcmp(_enum, "VK_DBG_LAYER_LEVEL_NONE"))
+ return VK_DBG_LAYER_LEVEL_NONE;
return 0;
}
const char *getLayerOption(const char *_option)
@@ -120,7 +120,7 @@
std::map<std::string, std::string>::const_iterator it;
if (!m_fileIsParsed)
{
- parseFile("xgl_layer_settings.txt");
+ parseFile("vk_layer_settings.txt");
}
if ((it = m_valueMap.find(_option)) == m_valueMap.end())
@@ -133,7 +133,7 @@
{
if (!m_fileIsParsed)
{
- parseFile("xgl_layer_settings.txt");
+ parseFile("vk_layer_settings.txt");
}
m_valueMap[_option] = _val;
diff --git a/layers/layers_msg.h b/layers/layers_msg.h
index 3f57250..b352596 100644
--- a/layers/layers_msg.h
+++ b/layers/layers_msg.h
@@ -1,5 +1,5 @@
/*
- * XGL
+ * Vulkan
*
* Copyright (C) 2014 LunarG, Inc.
*
@@ -24,17 +24,17 @@
#include <stdio.h>
#include <stdbool.h>
-static XGL_LAYER_DBG_FUNCTION_NODE *g_pDbgFunctionHead = NULL;
-static XGL_LAYER_DBG_REPORT_LEVEL g_reportingLevel = XGL_DBG_LAYER_LEVEL_INFO;
-static XGL_LAYER_DBG_ACTION g_debugAction = XGL_DBG_LAYER_ACTION_LOG_MSG;
+static VK_LAYER_DBG_FUNCTION_NODE *g_pDbgFunctionHead = NULL;
+static VK_LAYER_DBG_REPORT_LEVEL g_reportingLevel = VK_DBG_LAYER_LEVEL_INFO;
+static VK_LAYER_DBG_ACTION g_debugAction = VK_DBG_LAYER_ACTION_LOG_MSG;
static bool g_actionIsDefault = true;
static FILE *g_logFile = NULL;
// Utility function to handle reporting
// If callbacks are enabled, use them, otherwise use printf
-static void layerCbMsg(XGL_DBG_MSG_TYPE msgType,
- XGL_VALIDATION_LEVEL validationLevel,
- XGL_BASE_OBJECT srcObject,
+static void layerCbMsg(VK_DBG_MSG_TYPE msgType,
+ VK_VALIDATION_LEVEL validationLevel,
+ VK_BASE_OBJECT srcObject,
size_t location,
int32_t msgCode,
const char* pLayerPrefix,
@@ -44,38 +44,38 @@
g_logFile = stdout;
}
- if (g_debugAction & (XGL_DBG_LAYER_ACTION_LOG_MSG | XGL_DBG_LAYER_ACTION_CALLBACK)) {
- XGL_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
+ if (g_debugAction & (VK_DBG_LAYER_ACTION_LOG_MSG | VK_DBG_LAYER_ACTION_CALLBACK)) {
+ VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
switch (msgType) {
- case XGL_DBG_MSG_ERROR:
- if (g_reportingLevel <= XGL_DBG_LAYER_LEVEL_ERROR) {
- if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG) {
+ case VK_DBG_MSG_ERROR:
+ if (g_reportingLevel <= VK_DBG_LAYER_LEVEL_ERROR) {
+ if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG) {
fprintf(g_logFile, "{%s}ERROR : %s\n", pLayerPrefix, pMsg);
fflush(g_logFile);
}
- if (g_debugAction & XGL_DBG_LAYER_ACTION_CALLBACK)
+ if (g_debugAction & VK_DBG_LAYER_ACTION_CALLBACK)
while (pTrav) {
pTrav->pfnMsgCallback(msgType, validationLevel, srcObject, location, msgCode, pMsg, pTrav->pUserData);
pTrav = pTrav->pNext;
}
}
break;
- case XGL_DBG_MSG_WARNING:
- if (g_reportingLevel <= XGL_DBG_LAYER_LEVEL_WARN) {
- if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
+ case VK_DBG_MSG_WARNING:
+ if (g_reportingLevel <= VK_DBG_LAYER_LEVEL_WARN) {
+ if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
fprintf(g_logFile, "{%s}WARN : %s\n", pLayerPrefix, pMsg);
- if (g_debugAction & XGL_DBG_LAYER_ACTION_CALLBACK)
+ if (g_debugAction & VK_DBG_LAYER_ACTION_CALLBACK)
while (pTrav) {
pTrav->pfnMsgCallback(msgType, validationLevel, srcObject, location, msgCode, pMsg, pTrav->pUserData);
pTrav = pTrav->pNext;
}
}
break;
- case XGL_DBG_MSG_PERF_WARNING:
- if (g_reportingLevel <= XGL_DBG_LAYER_LEVEL_PERF_WARN) {
- if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
+ case VK_DBG_MSG_PERF_WARNING:
+ if (g_reportingLevel <= VK_DBG_LAYER_LEVEL_PERF_WARN) {
+ if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
fprintf(g_logFile, "{%s}PERF_WARN : %s\n", pLayerPrefix, pMsg);
- if (g_debugAction & XGL_DBG_LAYER_ACTION_CALLBACK)
+ if (g_debugAction & VK_DBG_LAYER_ACTION_CALLBACK)
while (pTrav) {
pTrav->pfnMsgCallback(msgType, validationLevel, srcObject, location, msgCode, pMsg, pTrav->pUserData);
pTrav = pTrav->pNext;
@@ -83,10 +83,10 @@
}
break;
default:
- if (g_reportingLevel <= XGL_DBG_LAYER_LEVEL_INFO) {
- if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
+ if (g_reportingLevel <= VK_DBG_LAYER_LEVEL_INFO) {
+ if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
fprintf(g_logFile, "{%s}INFO : %s\n", pLayerPrefix, pMsg);
- if (g_debugAction & XGL_DBG_LAYER_ACTION_CALLBACK)
+ if (g_debugAction & VK_DBG_LAYER_ACTION_CALLBACK)
while (pTrav) {
pTrav->pfnMsgCallback(msgType, validationLevel, srcObject, location, msgCode, pMsg, pTrav->pUserData);
pTrav = pTrav->pNext;
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 5b47bfc..71b8a5a 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -32,8 +32,8 @@
using namespace std;
#include "loader_platform.h"
-#include "xgl_dispatch_table_helper.h"
-#include "xgl_struct_string_helper_cpp.h"
+#include "vk_dispatch_table_helper.h"
+#include "vk_struct_string_helper_cpp.h"
#include "mem_tracker.h"
#include "layers_config.h"
// The following is #included again to catch certain OS-specific functions
@@ -41,8 +41,8 @@
#include "loader_platform.h"
#include "layers_msg.h"
-static XGL_LAYER_DISPATCH_TABLE nextTable;
-static XGL_BASE_LAYER_OBJECT *pCurObj;
+static VK_LAYER_DISPATCH_TABLE nextTable;
+static VK_BASE_LAYER_OBJECT *pCurObj;
static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_initOnce);
// TODO : This can be much smarter, using separate locks for separate global data
static int globalLockInitialized = 0;
@@ -50,18 +50,18 @@
#define MAX_BINDING 0xFFFFFFFF
-map<XGL_CMD_BUFFER, MT_CB_INFO*> cbMap;
-map<XGL_GPU_MEMORY, MT_MEM_OBJ_INFO*> memObjMap;
-map<XGL_OBJECT, MT_OBJ_INFO*> objectMap;
+map<VK_CMD_BUFFER, MT_CB_INFO*> cbMap;
+map<VK_GPU_MEMORY, MT_MEM_OBJ_INFO*> memObjMap;
+map<VK_OBJECT, MT_OBJ_INFO*> objectMap;
map<uint64_t, MT_FENCE_INFO*> fenceMap; // Map fenceId to fence info
-map<XGL_QUEUE, MT_QUEUE_INFO*> queueMap;
+map<VK_QUEUE, MT_QUEUE_INFO*> queueMap;
// TODO : Add per-device fence completion
static uint64_t g_currentFenceId = 1;
-static XGL_DEVICE globalDevice = NULL;
+static VK_DEVICE globalDevice = NULL;
// Add new queue for this device to map container
-static void addQueueInfo(const XGL_QUEUE queue)
+static void addQueueInfo(const VK_QUEUE queue)
{
MT_QUEUE_INFO* pInfo = new MT_QUEUE_INFO;
pInfo->lastRetiredId = 0;
@@ -72,23 +72,23 @@
static void deleteQueueInfoList(void)
{
// Process queue list, cleaning up each entry before deleting
- for (map<XGL_QUEUE, MT_QUEUE_INFO*>::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) {
+ for (map<VK_QUEUE, MT_QUEUE_INFO*>::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) {
(*ii).second->pQueueCmdBuffers.clear();
}
queueMap.clear();
}
// Add new CBInfo for this cb to map container
-static void addCBInfo(const XGL_CMD_BUFFER cb)
+static void addCBInfo(const VK_CMD_BUFFER cb)
{
MT_CB_INFO* pInfo = new MT_CB_INFO;
- memset(pInfo, 0, (sizeof(MT_CB_INFO) - sizeof(list<XGL_GPU_MEMORY>)));
+ memset(pInfo, 0, (sizeof(MT_CB_INFO) - sizeof(list<VK_GPU_MEMORY>)));
pInfo->cmdBuffer = cb;
cbMap[cb] = pInfo;
}
// Return ptr to Info in CB map, or NULL if not found
-static MT_CB_INFO* getCBInfo(const XGL_CMD_BUFFER cb)
+static MT_CB_INFO* getCBInfo(const VK_CMD_BUFFER cb)
{
MT_CB_INFO* pCBInfo = NULL;
if (cbMap.find(cb) != cbMap.end()) {
@@ -98,7 +98,7 @@
}
// Return object info for 'object' or return NULL if no info exists
-static MT_OBJ_INFO* getObjectInfo(const XGL_OBJECT object)
+static MT_OBJ_INFO* getObjectInfo(const VK_OBJECT object)
{
MT_OBJ_INFO* pObjInfo = NULL;
@@ -108,7 +108,7 @@
return pObjInfo;
}
-static MT_OBJ_INFO* addObjectInfo(XGL_OBJECT object, XGL_STRUCTURE_TYPE sType, const void *pCreateInfo, const int struct_size, const char *name_prefix)
+static MT_OBJ_INFO* addObjectInfo(VK_OBJECT object, VK_STRUCTURE_TYPE sType, const void *pCreateInfo, const int struct_size, const char *name_prefix)
{
MT_OBJ_INFO* pInfo = new MT_OBJ_INFO;
memset(pInfo, 0, sizeof(MT_OBJ_INFO));
@@ -124,7 +124,7 @@
}
// Add a fence, creating one if necessary to our list of fences/fenceIds
-static uint64_t addFenceInfo(XGL_FENCE fence, XGL_QUEUE queue)
+static uint64_t addFenceInfo(VK_FENCE fence, VK_QUEUE queue)
{
// Create fence object
MT_FENCE_INFO* pFenceInfo = new MT_FENCE_INFO;
@@ -133,15 +133,15 @@
memset(pFenceInfo, 0, sizeof(MT_FENCE_INFO));
// If no fence, create an internal fence to track the submissions
if (fence == NULL) {
- XGL_FENCE_CREATE_INFO fci;
- fci.sType = XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+ VK_FENCE_CREATE_INFO fci;
+ fci.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fci.pNext = NULL;
- fci.flags = static_cast<XGL_FENCE_CREATE_FLAGS>(0);
+ fci.flags = static_cast<VK_FENCE_CREATE_FLAGS>(0);
nextTable.CreateFence(globalDevice, &fci, &pFenceInfo->fence);
- addObjectInfo(pFenceInfo->fence, fci.sType, &fci, sizeof(XGL_FENCE_CREATE_INFO), "internalFence");
- pFenceInfo->localFence = XGL_TRUE;
+ addObjectInfo(pFenceInfo->fence, fci.sType, &fci, sizeof(VK_FENCE_CREATE_INFO), "internalFence");
+ pFenceInfo->localFence = VK_TRUE;
} else {
- pFenceInfo->localFence = XGL_FALSE;
+ pFenceInfo->localFence = VK_FALSE;
pFenceInfo->fence = fence;
}
pFenceInfo->queue = queue;
@@ -159,7 +159,7 @@
map<uint64_t, MT_FENCE_INFO*>::iterator item;
MT_FENCE_INFO* pDelInfo = fenceMap[fenceId];
if (pDelInfo != NULL) {
- if (pDelInfo->localFence == XGL_TRUE) {
+ if (pDelInfo->localFence == VK_TRUE) {
nextTable.DestroyObject(pDelInfo->fence);
}
delete pDelInfo;
@@ -171,11 +171,11 @@
}
// Search through list for this fence, deleting all items before it (with lower IDs) and updating lastRetiredId
-static void updateFenceTracking(XGL_FENCE fence)
+static void updateFenceTracking(VK_FENCE fence)
{
MT_FENCE_INFO *pCurFenceInfo = NULL;
uint64_t fenceId = 0;
- XGL_QUEUE queue = NULL;
+ VK_QUEUE queue = NULL;
for (map<uint64_t, MT_FENCE_INFO*>::iterator ii=fenceMap.begin(); ii!=fenceMap.end(); ++ii) {
if ((*ii).second != NULL) {
@@ -189,7 +189,7 @@
// Update fence state in fenceCreateInfo structure
MT_OBJ_INFO* pObjectInfo = getObjectInfo(fence);
if (pObjectInfo != NULL) {
- pObjectInfo->create_info.fence_create_info.flags = XGL_FENCE_CREATE_SIGNALED_BIT;
+ pObjectInfo->create_info.fence_create_info.flags = VK_FENCE_CREATE_SIGNALED_BIT;
}
}
}
@@ -198,25 +198,25 @@
// Utility function that determines if a fenceId has been retired yet
static bool32_t fenceRetired(uint64_t fenceId)
{
- bool32_t result = XGL_FALSE;
+ bool32_t result = VK_FALSE;
MT_FENCE_INFO* pFenceInfo = fenceMap[fenceId];
if (pFenceInfo != 0)
{
MT_QUEUE_INFO* pQueueInfo = queueMap[pFenceInfo->queue];
if (fenceId <= pQueueInfo->lastRetiredId)
{
- result = XGL_TRUE;
+ result = VK_TRUE;
}
} else { // If not in list, fence has been retired and deleted
- result = XGL_TRUE;
+ result = VK_TRUE;
}
return result;
}
// Return the fence associated with a fenceId
-static XGL_FENCE getFenceFromId(uint64_t fenceId)
+static VK_FENCE getFenceFromId(uint64_t fenceId)
{
- XGL_FENCE fence = NULL;
+ VK_FENCE fence = NULL;
if (fenceId != 0) {
// Search for an item with this fenceId
if (fenceMap.find(fenceId) != fenceMap.end()) {
@@ -233,7 +233,7 @@
}
// Helper routine that updates the fence list for a specific queue to all-retired
-static void retireQueueFences(XGL_QUEUE queue)
+static void retireQueueFences(VK_QUEUE queue)
{
MT_QUEUE_INFO *pQueueInfo = queueMap[queue];
pQueueInfo->lastRetiredId = pQueueInfo->lastSubmittedId;
@@ -253,11 +253,11 @@
}
// Helper routine that updates fence list for all queues to all-retired
-static void retireDeviceFences(XGL_DEVICE device)
+static void retireDeviceFences(VK_DEVICE device)
{
// Process each queue for device
// TODO: Add multiple device support
- for (map<XGL_QUEUE, MT_QUEUE_INFO*>::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) {
+ for (map<VK_QUEUE, MT_QUEUE_INFO*>::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) {
retireQueueFences((*ii).first);
}
}
@@ -265,15 +265,15 @@
// Returns True if a memory reference is present in a Queue's memory reference list
// Queue is validated by caller
static bool32_t checkMemRef(
- XGL_QUEUE queue,
- XGL_GPU_MEMORY mem)
+ VK_QUEUE queue,
+ VK_GPU_MEMORY mem)
{
- bool32_t result = XGL_FALSE;
- list<XGL_GPU_MEMORY>::iterator it;
+ bool32_t result = VK_FALSE;
+ list<VK_GPU_MEMORY>::iterator it;
MT_QUEUE_INFO *pQueueInfo = queueMap[queue];
for (it = pQueueInfo->pMemRefList.begin(); it != pQueueInfo->pMemRefList.end(); ++it) {
if ((*it) == mem) {
- result = XGL_TRUE;
+ result = VK_TRUE;
break;
}
}
@@ -281,18 +281,18 @@
}
static bool32_t validateQueueMemRefs(
- XGL_QUEUE queue,
+ VK_QUEUE queue,
uint32_t cmdBufferCount,
- const XGL_CMD_BUFFER *pCmdBuffers)
+ const VK_CMD_BUFFER *pCmdBuffers)
{
- bool32_t result = XGL_TRUE;
+ bool32_t result = VK_TRUE;
// Verify Queue
MT_QUEUE_INFO *pQueueInfo = queueMap[queue];
if (pQueueInfo == NULL) {
char str[1024];
- sprintf(str, "Unknown Queue %p specified in xglQueueSubmit", queue);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str);
+ sprintf(str, "Unknown Queue %p specified in vkQueueSubmit", queue);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str);
}
else {
// Iterate through all CBs in pCmdBuffers
@@ -300,31 +300,31 @@
MT_CB_INFO* pCBInfo = getCBInfo(pCmdBuffers[i]);
if (!pCBInfo) {
char str[1024];
- sprintf(str, "Unable to find info for CB %p in order to check memory references in xglQueueSubmit for queue %p", (void*)pCmdBuffers[i], queue);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_INVALID_CB, "MEM", str);
- result = XGL_FALSE;
+ sprintf(str, "Unable to find info for CB %p in order to check memory references in vkQueueSubmit for queue %p", (void*)pCmdBuffers[i], queue);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_INVALID_CB, "MEM", str);
+ result = VK_FALSE;
} else {
// Validate that all actual references are accounted for in pMemRefs
- for (list<XGL_GPU_MEMORY>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
+ for (list<VK_GPU_MEMORY>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
// Search for each memref in queues memreflist.
if (checkMemRef(queue, *it)) {
char str[1024];
sprintf(str, "Found Mem Obj %p binding to CB %p for queue %p", (*it), pCmdBuffers[i], queue);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_NONE, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_NONE, "MEM", str);
}
else {
char str[1024];
sprintf(str, "Queue %p Memory reference list for Command Buffer %p is missing ref to mem obj %p", queue, pCmdBuffers[i], (*it));
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_INVALID_MEM_REF, "MEM", str);
- result = XGL_FALSE;
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_INVALID_MEM_REF, "MEM", str);
+ result = VK_FALSE;
}
}
}
}
- if (result == XGL_TRUE) {
+ if (result == VK_TRUE) {
char str[1024];
sprintf(str, "Verified all memory dependencies for Queue %p are included in pMemRefs list", queue);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_NONE, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_NONE, "MEM", str);
// TODO : Could report mem refs in pMemRefs that AREN'T in mem list, that would be primarily informational
// Currently just noting that there is a difference
}
@@ -335,7 +335,7 @@
// Return ptr to info in map container containing mem, or NULL if not found
// Calls to this function should be wrapped in mutex
-static MT_MEM_OBJ_INFO* getMemObjInfo(const XGL_GPU_MEMORY mem)
+static MT_MEM_OBJ_INFO* getMemObjInfo(const VK_GPU_MEMORY mem)
{
MT_MEM_OBJ_INFO* pMemObjInfo = NULL;
@@ -345,14 +345,14 @@
return pMemObjInfo;
}
-static void addMemObjInfo(const XGL_GPU_MEMORY mem, const XGL_MEMORY_ALLOC_INFO* pAllocInfo)
+static void addMemObjInfo(const VK_GPU_MEMORY mem, const VK_MEMORY_ALLOC_INFO* pAllocInfo)
{
MT_MEM_OBJ_INFO* pInfo = new MT_MEM_OBJ_INFO;
pInfo->refCount = 0;
- memset(&pInfo->allocInfo, 0, sizeof(XGL_MEMORY_ALLOC_INFO));
+ memset(&pInfo->allocInfo, 0, sizeof(VK_MEMORY_ALLOC_INFO));
- if (pAllocInfo) { // MEM alloc created by xglWsiX11CreatePresentableImage() doesn't have alloc info struct
- memcpy(&pInfo->allocInfo, pAllocInfo, sizeof(XGL_MEMORY_ALLOC_INFO));
+ if (pAllocInfo) { // MEM alloc created by vkWsiX11CreatePresentableImage() doesn't have alloc info struct
+ memcpy(&pInfo->allocInfo, pAllocInfo, sizeof(VK_MEMORY_ALLOC_INFO));
// TODO: Update for real hardware, actually process allocation info structures
pInfo->allocInfo.pNext = NULL;
}
@@ -362,27 +362,27 @@
// Find CB Info and add mem binding to list container
// Find Mem Obj Info and add CB binding to list container
-static bool32_t updateCBBinding(const XGL_CMD_BUFFER cb, const XGL_GPU_MEMORY mem)
+static bool32_t updateCBBinding(const VK_CMD_BUFFER cb, const VK_GPU_MEMORY mem)
{
- bool32_t result = XGL_TRUE;
+ bool32_t result = VK_TRUE;
// First update CB binding in MemObj mini CB list
MT_MEM_OBJ_INFO* pMemInfo = getMemObjInfo(mem);
if (!pMemInfo) {
char str[1024];
sprintf(str, "Trying to bind mem obj %p to CB %p but no info for that mem obj.\n Was it correctly allocated? Did it already get freed?", mem, cb);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
- result = XGL_FALSE;
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+ result = VK_FALSE;
} else {
// Search for cmd buffer object in memory object's binding list
- bool32_t found = XGL_FALSE;
- for (list<XGL_CMD_BUFFER>::iterator it = pMemInfo->pCmdBufferBindings.begin(); it != pMemInfo->pCmdBufferBindings.end(); ++it) {
+ bool32_t found = VK_FALSE;
+ for (list<VK_CMD_BUFFER>::iterator it = pMemInfo->pCmdBufferBindings.begin(); it != pMemInfo->pCmdBufferBindings.end(); ++it) {
if ((*it) == cb) {
- found = XGL_TRUE;
+ found = VK_TRUE;
break;
}
}
// If not present, add to list
- if (found == XGL_FALSE) {
+ if (found == VK_FALSE) {
pMemInfo->pCmdBufferBindings.push_front(cb);
pMemInfo->refCount++;
}
@@ -392,19 +392,19 @@
if (!pCBInfo) {
char str[1024];
sprintf(str, "Trying to bind mem obj %p to CB %p but no info for that CB. Was it CB incorrectly destroyed?", mem, cb);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
- result = XGL_FALSE;
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+ result = VK_FALSE;
} else {
// Search for memory object in cmd buffer's binding list
- bool32_t found = XGL_FALSE;
- for (list<XGL_GPU_MEMORY>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
+ bool32_t found = VK_FALSE;
+ for (list<VK_GPU_MEMORY>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
if ((*it) == mem) {
- found = XGL_TRUE;
+ found = VK_TRUE;
break;
}
}
// If not present, add to list
- if (found == XGL_FALSE) {
+ if (found == VK_FALSE) {
pCBInfo->pMemObjList.push_front(mem);
}
}
@@ -414,7 +414,7 @@
// Clear the CB Binding for mem
// Calls to this function should be wrapped in mutex
-static void clearCBBinding(const XGL_CMD_BUFFER cb, const XGL_GPU_MEMORY mem)
+static void clearCBBinding(const VK_CMD_BUFFER cb, const VK_GPU_MEMORY mem)
{
MT_MEM_OBJ_INFO* pInfo = getMemObjInfo(mem);
// TODO : Having this check is not ideal, really if memInfo was deleted,
@@ -427,21 +427,21 @@
}
// Free bindings related to CB
-static bool32_t freeCBBindings(const XGL_CMD_BUFFER cb)
+static bool32_t freeCBBindings(const VK_CMD_BUFFER cb)
{
- bool32_t result = XGL_TRUE;
+ bool32_t result = VK_TRUE;
MT_CB_INFO* pCBInfo = getCBInfo(cb);
if (!pCBInfo) {
char str[1024];
sprintf(str, "Unable to find global CB info %p for deletion", cb);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
- result = XGL_FALSE;
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
+ result = VK_FALSE;
} else {
if (!fenceRetired(pCBInfo->fenceId)) {
deleteFenceInfo(pCBInfo->fenceId);
}
- for (list<XGL_GPU_MEMORY>::iterator it=pCBInfo->pMemObjList.begin(); it!=pCBInfo->pMemObjList.end(); ++it) {
+ for (list<VK_GPU_MEMORY>::iterator it=pCBInfo->pMemObjList.begin(); it!=pCBInfo->pMemObjList.end(); ++it) {
clearCBBinding(cb, (*it));
}
pCBInfo->pMemObjList.clear();
@@ -452,12 +452,12 @@
// Delete CBInfo from list along with all of it's mini MemObjInfo
// and also clear mem references to CB
// TODO : When should this be called? There's no Destroy of CBs that I see
-static bool32_t deleteCBInfo(const XGL_CMD_BUFFER cb)
+static bool32_t deleteCBInfo(const VK_CMD_BUFFER cb)
{
- bool32_t result = XGL_TRUE;
+ bool32_t result = VK_TRUE;
result = freeCBBindings(cb);
// Delete the CBInfo info
- if (result == XGL_TRUE) {
+ if (result == VK_TRUE) {
if (cbMap.find(cb) != cbMap.end()) {
MT_CB_INFO* pDelInfo = cbMap[cb];
delete pDelInfo;
@@ -470,8 +470,8 @@
// Delete the entire CB list
static bool32_t deleteCBInfoList()
{
- bool32_t result = XGL_TRUE;
- for (map<XGL_CMD_BUFFER, MT_CB_INFO*>::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) {
+ bool32_t result = VK_TRUE;
+ for (map<VK_CMD_BUFFER, MT_CB_INFO*>::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) {
freeCBBindings((*ii).first);
delete (*ii).second;
}
@@ -483,25 +483,25 @@
{
uint32_t refCount = 0; // Count found references
- for (list<XGL_CMD_BUFFER>::const_iterator it = pMemObjInfo->pCmdBufferBindings.begin(); it != pMemObjInfo->pCmdBufferBindings.end(); ++it) {
+ for (list<VK_CMD_BUFFER>::const_iterator it = pMemObjInfo->pCmdBufferBindings.begin(); it != pMemObjInfo->pCmdBufferBindings.end(); ++it) {
refCount++;
char str[1024];
sprintf(str, "Command Buffer %p has reference to mem obj %p", (*it), pMemObjInfo->mem);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, (*it), 0, MEMTRACK_NONE, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (*it), 0, MEMTRACK_NONE, "MEM", str);
}
- for (list<XGL_OBJECT>::const_iterator it = pMemObjInfo->pObjBindings.begin(); it != pMemObjInfo->pObjBindings.end(); ++it) {
+ for (list<VK_OBJECT>::const_iterator it = pMemObjInfo->pObjBindings.begin(); it != pMemObjInfo->pObjBindings.end(); ++it) {
char str[1024];
- sprintf(str, "XGL Object %p has reference to mem obj %p", (*it), pMemObjInfo->mem);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, (*it), 0, MEMTRACK_NONE, "MEM", str);
+ sprintf(str, "VK Object %p has reference to mem obj %p", (*it), pMemObjInfo->mem);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (*it), 0, MEMTRACK_NONE, "MEM", str);
}
if (refCount != pMemObjInfo->refCount) {
char str[1024];
sprintf(str, "Refcount of %u for Mem Obj %p does't match reported refs of %u", pMemObjInfo->refCount, pMemObjInfo->mem, refCount);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pMemObjInfo->mem, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pMemObjInfo->mem, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
}
}
-static void deleteMemObjInfo(XGL_GPU_MEMORY mem)
+static void deleteMemObjInfo(VK_GPU_MEMORY mem)
{
MT_MEM_OBJ_INFO* pDelInfo = memObjMap[mem];
if (memObjMap.find(mem) != memObjMap.end()) {
@@ -512,50 +512,50 @@
}
// Check if fence for given CB is completed
-static bool32_t checkCBCompleted(const XGL_CMD_BUFFER cb)
+static bool32_t checkCBCompleted(const VK_CMD_BUFFER cb)
{
- bool32_t result = XGL_TRUE;
+ bool32_t result = VK_TRUE;
MT_CB_INFO* pCBInfo = getCBInfo(cb);
if (!pCBInfo) {
char str[1024];
sprintf(str, "Unable to find global CB info %p to check for completion", cb);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
- result = XGL_FALSE;
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
+ result = VK_FALSE;
} else {
if (!fenceRetired(pCBInfo->fenceId)) {
char str[1024];
sprintf(str, "FenceId %" PRIx64", fence %p for CB %p has not been checked for completion", pCBInfo->fenceId, getFenceFromId(pCBInfo->fenceId), cb);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_NONE, "MEM", str);
- result = XGL_FALSE;
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_NONE, "MEM", str);
+ result = VK_FALSE;
}
}
return result;
}
-static bool32_t freeMemObjInfo(XGL_GPU_MEMORY mem, bool internal)
+static bool32_t freeMemObjInfo(VK_GPU_MEMORY mem, bool internal)
{
- bool32_t result = XGL_TRUE;
+ bool32_t result = VK_TRUE;
// Parse global list to find info w/ mem
MT_MEM_OBJ_INFO* pInfo = getMemObjInfo(mem);
if (!pInfo) {
char str[1024];
sprintf(str, "Couldn't find mem info object for %p\n Was %p never allocated or previously freed?", (void*)mem, (void*)mem);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
- result = XGL_FALSE;
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+ result = VK_FALSE;
} else {
if (pInfo->allocInfo.allocationSize == 0 && !internal) {
char str[1024];
sprintf(str, "Attempting to free memory associated with a Presentable Image, %p, this should not be explicitly freed\n", (void*)mem);
- layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
- result = XGL_FALSE;
+ layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+ result = VK_FALSE;
} else {
// Clear any CB bindings for completed CBs
// TODO : Is there a better place to do this?
- list<XGL_CMD_BUFFER>::iterator it = pInfo->pCmdBufferBindings.begin();
- list<XGL_CMD_BUFFER>::iterator temp;
+ list<VK_CMD_BUFFER>::iterator it = pInfo->pCmdBufferBindings.begin();
+ list<VK_CMD_BUFFER>::iterator temp;
while (it != pInfo->pCmdBufferBindings.end()) {
- if (XGL_TRUE == checkCBCompleted(*it)) {
+ if (VK_TRUE == checkCBCompleted(*it)) {
temp = it;
++temp;
freeCBBindings(*it);
@@ -570,9 +570,9 @@
// If references remain, report the error and can search CB list to find references
char str[1024];
sprintf(str, "Freeing mem obj %p while it still has references", (void*)mem);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_FREED_MEM_REF, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_FREED_MEM_REF, "MEM", str);
reportMemReferences(pInfo);
- result = XGL_FALSE;
+ result = VK_FALSE;
}
// Delete mem obj info
deleteMemObjInfo(mem);
@@ -585,32 +585,32 @@
// 1. Remove ObjectInfo from MemObjInfo list container of obj bindings & free it
// 2. Decrement refCount for MemObjInfo
// 3. Clear MemObjInfo ptr from ObjectInfo
-static bool32_t clearObjectBinding(XGL_OBJECT object)
+static bool32_t clearObjectBinding(VK_OBJECT object)
{
- bool32_t result = XGL_FALSE;
+ bool32_t result = VK_FALSE;
MT_OBJ_INFO* pObjInfo = getObjectInfo(object);
if (!pObjInfo) {
char str[1024];
sprintf(str, "Attempting to clear mem binding for object %p: devices, queues, command buffers, shaders and memory objects do not have external memory requirements and it is unneccessary to call bind/unbindObjectMemory on them.", object);
- layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INVALID_OBJECT, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INVALID_OBJECT, "MEM", str);
} else {
if (!pObjInfo->pMemObjInfo) {
char str[1024];
sprintf(str, "Attempting to clear mem binding on obj %p but it has no binding.", (void*)object);
- layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MEM_OBJ_CLEAR_EMPTY_BINDINGS, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MEM_OBJ_CLEAR_EMPTY_BINDINGS, "MEM", str);
} else {
- for (list<XGL_OBJECT>::iterator it = pObjInfo->pMemObjInfo->pObjBindings.begin(); it != pObjInfo->pMemObjInfo->pObjBindings.end(); ++it) {
+ for (list<VK_OBJECT>::iterator it = pObjInfo->pMemObjInfo->pObjBindings.begin(); it != pObjInfo->pMemObjInfo->pObjBindings.end(); ++it) {
pObjInfo->pMemObjInfo->refCount--;
pObjInfo->pMemObjInfo = NULL;
it = pObjInfo->pMemObjInfo->pObjBindings.erase(it);
- result = XGL_TRUE;
+ result = VK_TRUE;
break;
}
- if (result == XGL_FALSE) {
+ if (result == VK_FALSE) {
char str[1024];
sprintf(str, "While trying to clear mem binding for object %p, unable to find that object referenced by mem obj %p",
object, pObjInfo->pMemObjInfo->mem);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
}
}
}
@@ -622,38 +622,38 @@
// IF a previous binding existed, clear it
// Add reference from objectInfo to memoryInfo
// Add reference off of objInfo
-// Return XGL_TRUE if addition is successful, XGL_FALSE otherwise
-static bool32_t updateObjectBinding(XGL_OBJECT object, XGL_GPU_MEMORY mem)
+// Return VK_TRUE if addition is successful, VK_FALSE otherwise
+static bool32_t updateObjectBinding(VK_OBJECT object, VK_GPU_MEMORY mem)
{
- bool32_t result = XGL_FALSE;
+ bool32_t result = VK_FALSE;
// Handle NULL case separately, just clear previous binding & decrement reference
- if (mem == XGL_NULL_HANDLE) {
+ if (mem == VK_NULL_HANDLE) {
clearObjectBinding(object);
- result = XGL_TRUE;
+ result = VK_TRUE;
} else {
char str[1024];
MT_OBJ_INFO* pObjInfo = getObjectInfo(object);
if (!pObjInfo) {
sprintf(str, "Attempting to update Binding of Obj(%p) that's not in global list()", (void*)object);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
- return XGL_FALSE;
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
+ return VK_FALSE;
}
// non-null case so should have real mem obj
MT_MEM_OBJ_INFO* pInfo = getMemObjInfo(mem);
if (!pInfo) {
sprintf(str, "While trying to bind mem for obj %p, couldn't find info for mem obj %p", (void*)object, (void*)mem);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
} else {
// Search for object in memory object's binding list
- bool32_t found = XGL_FALSE;
- for (list<XGL_OBJECT>::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) {
+ bool32_t found = VK_FALSE;
+ for (list<VK_OBJECT>::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) {
if ((*it) == object) {
- found = XGL_TRUE;
+ found = VK_TRUE;
break;
}
}
// If not present, add to list
- if (found == XGL_FALSE) {
+ if (found == VK_FALSE) {
pInfo->pObjBindings.push_front(object);
pInfo->refCount++;
}
@@ -661,19 +661,19 @@
if (pObjInfo->pMemObjInfo) {
clearObjectBinding(object); // Need to clear the previous object binding before setting new binding
sprintf(str, "Updating memory binding for object %p from mem obj %p to %p", object, pObjInfo->pMemObjInfo->mem, mem);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_NONE, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_NONE, "MEM", str);
}
// For image objects, make sure default memory state is correctly set
// TODO : What's the best/correct way to handle this?
- if (XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO == pObjInfo->sType) {
- if (pObjInfo->create_info.image_create_info.usage & (XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT)) {
+ if (VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO == pObjInfo->sType) {
+ if (pObjInfo->create_info.image_create_info.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_BIT)) {
// TODO:: More memory state transition stuff.
}
}
pObjInfo->pMemObjInfo = pInfo;
}
}
- return XGL_TRUE;
+ return VK_TRUE;
}
// Print details of global Obj tracking list
@@ -682,18 +682,18 @@
MT_OBJ_INFO* pInfo = NULL;
char str[1024];
sprintf(str, "Details of Object list of size %lu elements", objectMap.size());
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
- for (map<XGL_OBJECT, MT_OBJ_INFO*>::iterator ii=objectMap.begin(); ii!=objectMap.end(); ++ii) {
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ for (map<VK_OBJECT, MT_OBJ_INFO*>::iterator ii=objectMap.begin(); ii!=objectMap.end(); ++ii) {
pInfo = (*ii).second;
sprintf(str, " ObjInfo %p has object %p, pMemObjInfo %p", pInfo, pInfo->object, pInfo->pMemObjInfo);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pInfo->object, 0, MEMTRACK_NONE, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pInfo->object, 0, MEMTRACK_NONE, "MEM", str);
}
}
// For given Object, get 'mem' obj that it's bound to or NULL if no binding
-static XGL_GPU_MEMORY getMemBindingFromObject(const XGL_OBJECT object)
+static VK_GPU_MEMORY getMemBindingFromObject(const VK_OBJECT object)
{
- XGL_GPU_MEMORY mem = NULL;
+ VK_GPU_MEMORY mem = NULL;
MT_OBJ_INFO* pObjInfo = getObjectInfo(object);
if (pObjInfo) {
if (pObjInfo->pMemObjInfo) {
@@ -702,14 +702,14 @@
else {
char str[1024];
sprintf(str, "Trying to get mem binding for object %p but object has no mem binding", (void*)object);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", str);
printObjList();
}
}
else {
char str[1024];
sprintf(str, "Trying to get mem binding for object %p but no such object in global list", (void*)object);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INVALID_OBJECT, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INVALID_OBJECT, "MEM", str);
printObjList();
}
return mem;
@@ -722,38 +722,38 @@
// Just printing each msg individually for now, may want to package these into single large print
char str[1024];
sprintf(str, "MEM INFO : Details of Memory Object list of size %lu elements", memObjMap.size());
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
- for (map<XGL_GPU_MEMORY, MT_MEM_OBJ_INFO*>::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) {
+ for (map<VK_GPU_MEMORY, MT_MEM_OBJ_INFO*>::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) {
pInfo = (*ii).second;
sprintf(str, " ===MemObjInfo at %p===", (void*)pInfo);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
sprintf(str, " Mem object: %p", (void*)pInfo->mem);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
sprintf(str, " Ref Count: %u", pInfo->refCount);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
if (0 != pInfo->allocInfo.allocationSize) {
- string pAllocInfoMsg = xgl_print_xgl_memory_alloc_info(&pInfo->allocInfo, "{MEM}INFO : ");
+ string pAllocInfoMsg = vk_print_vk_memory_alloc_info(&pInfo->allocInfo, "{MEM}INFO : ");
sprintf(str, " Mem Alloc info:\n%s", pAllocInfoMsg.c_str());
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
} else {
- sprintf(str, " Mem Alloc info is NULL (alloc done by xglWsiX11CreatePresentableImage())");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ sprintf(str, " Mem Alloc info is NULL (alloc done by vkWsiX11CreatePresentableImage())");
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
}
- sprintf(str, " XGL OBJECT Binding list of size %lu elements:", pInfo->pObjBindings.size());
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
- for (list<XGL_OBJECT>::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) {
- sprintf(str, " XGL OBJECT %p", (*it));
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ sprintf(str, " VK OBJECT Binding list of size %lu elements:", pInfo->pObjBindings.size());
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ for (list<VK_OBJECT>::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) {
+ sprintf(str, " VK OBJECT %p", (*it));
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
}
- sprintf(str, " XGL Command Buffer (CB) binding list of size %lu elements", pInfo->pCmdBufferBindings.size());
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
- for (list<XGL_CMD_BUFFER>::iterator it = pInfo->pCmdBufferBindings.begin(); it != pInfo->pCmdBufferBindings.end(); ++it) {
- sprintf(str, " XGL CB %p", (*it));
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ sprintf(str, " VK Command Buffer (CB) binding list of size %lu elements", pInfo->pCmdBufferBindings.size());
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ for (list<VK_CMD_BUFFER>::iterator it = pInfo->pCmdBufferBindings.begin(); it != pInfo->pCmdBufferBindings.end(); ++it) {
+ sprintf(str, " VK CB %p", (*it));
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
}
}
}
@@ -763,19 +763,19 @@
char str[1024] = {0};
MT_CB_INFO* pCBInfo = NULL;
sprintf(str, "Details of CB list of size %lu elements", cbMap.size());
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
- for (map<XGL_CMD_BUFFER, MT_CB_INFO*>::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) {
+ for (map<VK_CMD_BUFFER, MT_CB_INFO*>::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) {
pCBInfo = (*ii).second;
sprintf(str, " CB Info (%p) has CB %p, fenceId %" PRIx64", and fence %p",
(void*)pCBInfo, (void*)pCBInfo->cmdBuffer, pCBInfo->fenceId,
(void*)getFenceFromId(pCBInfo->fenceId));
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
- for (list<XGL_GPU_MEMORY>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
+ for (list<VK_GPU_MEMORY>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
sprintf(str, " Mem obj %p", (*it));
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
}
}
}
@@ -787,7 +787,7 @@
getLayerOptionEnum("MemTrackerReportLevel", (uint32_t *) &g_reportingLevel);
g_actionIsDefault = getLayerOptionEnum("MemTrackerDebugAction", (uint32_t *) &g_debugAction);
- if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
+ if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
{
strOpt = getLayerOption("MemTrackerLogFilename");
if (strOpt)
@@ -800,20 +800,20 @@
// initialize Layer dispatch table
// TODO handle multiple GPUs
- xglGetProcAddrType fpNextGPA;
+ vkGetProcAddrType fpNextGPA;
fpNextGPA = pCurObj->pGPA;
assert(fpNextGPA);
- layer_initialize_dispatch_table(&nextTable, fpNextGPA, (XGL_PHYSICAL_GPU) pCurObj->nextObject);
+ layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);
- xglGetProcAddrType fpGetProcAddr = (xglGetProcAddrType)fpNextGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (char *) "xglGetProcAddr");
+ vkGetProcAddrType fpGetProcAddr = (vkGetProcAddrType)fpNextGPA((VK_PHYSICAL_GPU) pCurObj->nextObject, (char *) "vkGetProcAddr");
nextTable.GetProcAddr = fpGetProcAddr;
if (!globalLockInitialized)
{
// TODO/TBD: Need to delete this mutex sometime. How??? One
- // suggestion is to call this during xglCreateInstance(), and then we
- // can clean it up during xglDestroyInstance(). However, that requires
+ // suggestion is to call this during vkCreateInstance(), and then we
+ // can clean it up during vkDestroyInstance(). However, that requires
// that the layer have per-instance locks. We need to come back and
// address this soon.
loader_platform_thread_create_mutex(&globalLock);
@@ -821,39 +821,39 @@
}
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
pCurObj = gpuw;
loader_platform_thread_once(&g_initOnce, initMemTracker);
- XGL_RESULT result = nextTable.CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
+ VK_RESULT result = nextTable.CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
// Save off device in case we need it to create Fences
globalDevice = *pDevice;
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyDevice(XGL_DEVICE device)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device)
{
char str[1024];
- sprintf(str, "Printing List details prior to xglDestroyDevice()");
+ sprintf(str, "Printing List details prior to vkDestroyDevice()");
loader_platform_thread_lock_mutex(&globalLock);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, device, 0, MEMTRACK_NONE, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, device, 0, MEMTRACK_NONE, "MEM", str);
printMemList();
printCBList();
printObjList();
- if (XGL_FALSE == deleteCBInfoList()) {
- sprintf(str, "Issue deleting global CB list in xglDestroyDevice()");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, device, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
+ if (VK_FALSE == deleteCBInfoList()) {
+ sprintf(str, "Issue deleting global CB list in vkDestroyDevice()");
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, device, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
}
// Report any memory leaks
MT_MEM_OBJ_INFO* pInfo = NULL;
- for (map<XGL_GPU_MEMORY, MT_MEM_OBJ_INFO*>::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) {
+ for (map<VK_GPU_MEMORY, MT_MEM_OBJ_INFO*>::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) {
pInfo = (*ii).second;
if (pInfo->allocInfo.allocationSize != 0) {
- sprintf(str, "Mem Object %p has not been freed. You should clean up this memory by calling xglFreeMemory(%p) prior to xglDestroyDevice().",
+ sprintf(str, "Mem Object %p has not been freed. You should clean up this memory by calling vkFreeMemory(%p) prior to vkDestroyDevice().",
pInfo->mem, pInfo->mem);
- layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, pInfo->mem, 0, MEMTRACK_MEMORY_LEAK, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, pInfo->mem, 0, MEMTRACK_MEMORY_LEAK, "MEM", str);
}
}
@@ -861,54 +861,54 @@
deleteQueueInfoList();
loader_platform_thread_unlock_mutex(&globalLock);
- XGL_RESULT result = nextTable.DestroyDevice(device);
+ VK_RESULT result = nextTable.DestroyDevice(device);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu, const char* pExtName)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
- XGL_RESULT result;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+ VK_RESULT result;
/* This entrypoint is NOT going to init its own dispatch table since loader calls here early */
if (!strcmp(pExtName, "MemTracker"))
{
- result = XGL_SUCCESS;
+ result = VK_SUCCESS;
} else if (nextTable.GetExtensionSupport != NULL)
{
- result = nextTable.GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);
+ result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);
} else
{
- result = XGL_ERROR_INVALID_EXTENSION;
+ result = VK_ERROR_INVALID_EXTENSION;
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount,
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount,
size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
{
if (gpu != NULL)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
pCurObj = gpuw;
loader_platform_thread_once(&g_initOnce, initMemTracker);
- XGL_RESULT result = nextTable.EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount,
+ VK_RESULT result = nextTable.EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount,
maxStringSize, pOutLayerCount, pOutLayers, pReserved);
return result;
} else
{
if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
- return XGL_ERROR_INVALID_POINTER;
+ return VK_ERROR_INVALID_POINTER;
// This layer compatible with all GPUs
*pOutLayerCount = 1;
strncpy((char *) pOutLayers[0], "MemTracker", maxStringSize);
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetDeviceQueue(XGL_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, XGL_QUEUE* pQueue)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetDeviceQueue(VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, VK_QUEUE* pQueue)
{
- XGL_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
- if (result == XGL_SUCCESS) {
+ VK_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
+ if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
addQueueInfo(*pQueue);
loader_platform_thread_unlock_mutex(&globalLock);
@@ -916,24 +916,24 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueAddMemReference(XGL_QUEUE queue, XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueAddMemReference(VK_QUEUE queue, VK_GPU_MEMORY mem)
{
- XGL_RESULT result = nextTable.QueueAddMemReference(queue, mem);
- if (result == XGL_SUCCESS) {
+ VK_RESULT result = nextTable.QueueAddMemReference(queue, mem);
+ if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
MT_QUEUE_INFO *pQueueInfo = queueMap[queue];
if (pQueueInfo == NULL) {
char str[1024];
sprintf(str, "Unknown Queue %p", queue);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str);
}
else {
- if (checkMemRef(queue, mem) == XGL_TRUE) {
+ if (checkMemRef(queue, mem) == VK_TRUE) {
// Alread in list, just warn
char str[1024];
sprintf(str, "Request to add a memory reference (%p) to Queue %p -- ref is already present in the queue's reference list", mem, queue);
- layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_REF, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_REF, "MEM", str);
}
else {
// Add to queue's memory reference list
@@ -945,21 +945,21 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueRemoveMemReference(XGL_QUEUE queue, XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueRemoveMemReference(VK_QUEUE queue, VK_GPU_MEMORY mem)
{
// TODO : Decrement ref count for this memory reference on this queue. Remove if ref count is zero.
- XGL_RESULT result = nextTable.QueueRemoveMemReference(queue, mem);
- if (result == XGL_SUCCESS) {
+ VK_RESULT result = nextTable.QueueRemoveMemReference(queue, mem);
+ if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
MT_QUEUE_INFO *pQueueInfo = queueMap[queue];
if (pQueueInfo == NULL) {
char str[1024];
sprintf(str, "Unknown Queue %p", queue);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str);
}
else {
- for (list<XGL_GPU_MEMORY>::iterator it = pQueueInfo->pMemRefList.begin(); it != pQueueInfo->pMemRefList.end(); ++it) {
+ for (list<VK_GPU_MEMORY>::iterator it = pQueueInfo->pMemRefList.begin(); it != pQueueInfo->pMemRefList.end(); ++it) {
if ((*it) == mem) {
it = pQueueInfo->pMemRefList.erase(it);
}
@@ -970,11 +970,11 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(
- XGL_QUEUE queue,
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit(
+ VK_QUEUE queue,
uint32_t cmdBufferCount,
- const XGL_CMD_BUFFER *pCmdBuffers,
- XGL_FENCE fence)
+ const VK_CMD_BUFFER *pCmdBuffers,
+ VK_FENCE fence)
{
loader_platform_thread_lock_mutex(&globalLock);
// TODO : Need to track fence and clear mem references when fence clears
@@ -988,20 +988,20 @@
pCBInfo->fenceId = fenceId;
}
- if (XGL_FALSE == validateQueueMemRefs(queue, cmdBufferCount, pCmdBuffers)) {
+ if (VK_FALSE == validateQueueMemRefs(queue, cmdBufferCount, pCmdBuffers)) {
char str[1024];
sprintf(str, "Unable to verify memory references for Queue %p", queue);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_MEM_REF, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_MEM_REF, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, getFenceFromId(fenceId));
+ VK_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, getFenceFromId(fenceId));
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglAllocMemory(XGL_DEVICE device, const XGL_MEMORY_ALLOC_INFO* pAllocInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem)
{
- XGL_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem);
+ VK_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem);
// TODO : Track allocations and overall size here
loader_platform_thread_lock_mutex(&globalLock);
addMemObjInfo(*pMem, pAllocInfo);
@@ -1010,93 +1010,93 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglFreeMemory(XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkFreeMemory(VK_GPU_MEMORY mem)
{
- /* From spec : A memory object is freed by calling xglFreeMemory() when it is no longer needed. Before
+ /* From spec : A memory object is freed by calling vkFreeMemory() when it is no longer needed. Before
* freeing a memory object, an application must ensure the memory object is unbound from
* all API objects referencing it and that it is not referenced by any queued command buffers
*/
loader_platform_thread_lock_mutex(&globalLock);
- if (XGL_FALSE == freeMemObjInfo(mem, false)) {
+ if (VK_FALSE == freeMemObjInfo(mem, false)) {
char str[1024];
sprintf(str, "Issue while freeing mem obj %p", (void*)mem);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_FREE_MEM_ERROR, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_FREE_MEM_ERROR, "MEM", str);
}
printMemList();
printObjList();
printCBList();
loader_platform_thread_unlock_mutex(&globalLock);
- XGL_RESULT result = nextTable.FreeMemory(mem);
+ VK_RESULT result = nextTable.FreeMemory(mem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSetMemoryPriority(XGL_GPU_MEMORY mem, XGL_MEMORY_PRIORITY priority)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkSetMemoryPriority(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority)
{
// TODO : Update tracking for this alloc
// Make sure memory is not pinned, which can't have priority set
- XGL_RESULT result = nextTable.SetMemoryPriority(mem, priority);
+ VK_RESULT result = nextTable.SetMemoryPriority(mem, priority);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglMapMemory(XGL_GPU_MEMORY mem, XGL_FLAGS flags, void** ppData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkMapMemory(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData)
{
// TODO : Track when memory is mapped
loader_platform_thread_lock_mutex(&globalLock);
MT_MEM_OBJ_INFO *pMemObj = getMemObjInfo(mem);
- if ((pMemObj->allocInfo.memProps & XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT) == 0) {
+ if ((pMemObj->allocInfo.memProps & VK_MEMORY_PROPERTY_CPU_VISIBLE_BIT) == 0) {
char str[1024];
- sprintf(str, "Mapping Memory (%p) without XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT set", (void*)mem);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_STATE, "MEM", str);
+ sprintf(str, "Mapping Memory (%p) without VK_MEMORY_PROPERTY_CPU_VISIBLE_BIT set", (void*)mem);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_STATE, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- XGL_RESULT result = nextTable.MapMemory(mem, flags, ppData);
+ VK_RESULT result = nextTable.MapMemory(mem, flags, ppData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglUnmapMemory(XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkUnmapMemory(VK_GPU_MEMORY mem)
{
// TODO : Track as memory gets unmapped, do we want to check what changed following map?
// Make sure that memory was ever mapped to begin with
- XGL_RESULT result = nextTable.UnmapMemory(mem);
+ VK_RESULT result = nextTable.UnmapMemory(mem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglPinSystemMemory(XGL_DEVICE device, const void* pSysMem, size_t memSize, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkPinSystemMemory(VK_DEVICE device, const void* pSysMem, size_t memSize, VK_GPU_MEMORY* pMem)
{
// TODO : Track this
// Verify that memory is actually pinnable
- XGL_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem);
+ VK_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenSharedMemory(XGL_DEVICE device, const XGL_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedMemory(VK_DEVICE device, const VK_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem)
{
// TODO : Track this
- XGL_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem);
+ VK_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenPeerMemory(XGL_DEVICE device, const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerMemory(VK_DEVICE device, const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem)
{
// TODO : Track this
- XGL_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem);
+ VK_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenPeerImage(XGL_DEVICE device, const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerImage(VK_DEVICE device, const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem)
{
// TODO : Track this
- XGL_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem);
+ VK_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyObject(XGL_OBJECT object)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object)
{
loader_platform_thread_lock_mutex(&globalLock);
// First check if this is a CmdBuffer
- if (NULL != getCBInfo((XGL_CMD_BUFFER)object)) {
- deleteCBInfo((XGL_CMD_BUFFER)object);
+ if (NULL != getCBInfo((VK_CMD_BUFFER)object)) {
+ deleteCBInfo((VK_CMD_BUFFER)object);
}
if (objectMap.find(object) != objectMap.end()) {
@@ -1104,14 +1104,14 @@
if (pDelInfo->pMemObjInfo) {
// Wsi allocated Memory is tied to image object so clear the binding and free that memory automatically
if (0 == pDelInfo->pMemObjInfo->allocInfo.allocationSize) { // Wsi allocated memory has NULL allocInfo w/ 0 size
- XGL_GPU_MEMORY memToFree = pDelInfo->pMemObjInfo->mem;
+ VK_GPU_MEMORY memToFree = pDelInfo->pMemObjInfo->mem;
clearObjectBinding(object);
freeMemObjInfo(memToFree, true);
}
else {
char str[1024];
- sprintf(str, "Destroying obj %p that is still bound to memory object %p\nYou should first clear binding by calling xglBindObjectMemory(%p, 0, XGL_NULL_HANDLE, 0)", object, (void*)pDelInfo->pMemObjInfo->mem, object);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_DESTROY_OBJECT_ERROR, "MEM", str);
+ sprintf(str, "Destroying obj %p that is still bound to memory object %p\nYou should first clear binding by calling vkBindObjectMemory(%p, 0, VK_NULL_HANDLE, 0)", object, (void*)pDelInfo->pMemObjInfo->mem, object);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_DESTROY_OBJECT_ERROR, "MEM", str);
// From the spec : If an object has previous memory binding, it is required to unbind memory from an API object before it is destroyed.
clearObjectBinding(object);
}
@@ -1121,28 +1121,28 @@
}
loader_platform_thread_unlock_mutex(&globalLock);
- XGL_RESULT result = nextTable.DestroyObject(object);
+ VK_RESULT result = nextTable.DestroyObject(object);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetObjectInfo(XGL_BASE_OBJECT object, XGL_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetObjectInfo(VK_BASE_OBJECT object, VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
{
// TODO : What to track here?
// Could potentially save returned mem requirements and validate values passed into BindObjectMemory for this object
// From spec : The only objects that are guaranteed to have no external memory requirements are devices, queues, command buffers, shaders and memory objects.
- XGL_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData);
+ VK_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBindObjectMemory(XGL_OBJECT object, uint32_t allocationIdx, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemory(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_MEMORY mem, VK_GPU_SIZE offset)
{
- XGL_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset);
+ VK_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset);
loader_platform_thread_lock_mutex(&globalLock);
// Track objects tied to memory
- if (XGL_FALSE == updateObjectBinding(object, mem)) {
+ if (VK_FALSE == updateObjectBinding(object, mem)) {
char str[1024];
sprintf(str, "Unable to set object %p binding to mem obj %p", (void*)object, (void*)mem);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
printObjList();
printMemList();
@@ -1150,28 +1150,28 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateFence(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFence(VK_DEVICE device, const VK_FENCE_CREATE_INFO* pCreateInfo, VK_FENCE* pFence)
{
- XGL_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence);
+ if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pFence, pCreateInfo->sType, pCreateInfo, sizeof(XGL_FENCE_CREATE_INFO), "fence");
+ addObjectInfo(*pFence, pCreateInfo->sType, pCreateInfo, sizeof(VK_FENCE_CREATE_INFO), "fence");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetFences(XGL_DEVICE device, uint32_t fenceCount, XGL_FENCE* pFences)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetFences(VK_DEVICE device, uint32_t fenceCount, VK_FENCE* pFences)
{
- XGL_RESULT result = nextTable.ResetFences(device, fenceCount, pFences);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.ResetFences(device, fenceCount, pFences);
+ if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
// Reset fence state in fenceCreateInfo structure
for (uint32_t i = 0; i < fenceCount; i++) {
MT_OBJ_INFO* pObjectInfo = getObjectInfo(pFences[i]);
if (pObjectInfo != NULL) {
pObjectInfo->create_info.fence_create_info.flags =
- static_cast<XGL_FENCE_CREATE_FLAGS>(pObjectInfo->create_info.fence_create_info.flags & ~XGL_FENCE_CREATE_SIGNALED_BIT);
+ static_cast<VK_FENCE_CREATE_FLAGS>(pObjectInfo->create_info.fence_create_info.flags & ~VK_FENCE_CREATE_SIGNALED_BIT);
}
}
loader_platform_thread_unlock_mutex(&globalLock);
@@ -1179,10 +1179,10 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFenceStatus(XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFenceStatus(VK_FENCE fence)
{
- XGL_RESULT result = nextTable.GetFenceStatus(fence);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.GetFenceStatus(fence);
+ if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
updateFenceTracking(fence);
loader_platform_thread_unlock_mutex(&globalLock);
@@ -1190,24 +1190,24 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWaitForFences(XGL_DEVICE device, uint32_t fenceCount, const XGL_FENCE* pFences, bool32_t waitAll, uint64_t timeout)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWaitForFences(VK_DEVICE device, uint32_t fenceCount, const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout)
{
// Verify fence status of submitted fences
for(uint32_t i = 0; i < fenceCount; i++) {
MT_OBJ_INFO* pObjectInfo = getObjectInfo(pFences[i]);
if (pObjectInfo != NULL) {
- if (pObjectInfo->create_info.fence_create_info.flags == XGL_FENCE_CREATE_SIGNALED_BIT) {
+ if (pObjectInfo->create_info.fence_create_info.flags == VK_FENCE_CREATE_SIGNALED_BIT) {
char str[1024];
- sprintf(str, "xglWaitForFences specified signaled-state Fence %p. Fences must be reset before being submitted", pFences[i]);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
+ sprintf(str, "vkWaitForFences specified signaled-state Fence %p. Fences must be reset before being submitted", pFences[i]);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
}
}
}
- XGL_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
+ VK_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
loader_platform_thread_lock_mutex(&globalLock);
- if (XGL_SUCCESS == result) {
+ if (VK_SUCCESS == result) {
if (waitAll || fenceCount == 1) { // Clear all the fences
for(uint32_t i = 0; i < fenceCount; i++) {
updateFenceTracking(pFences[i]);
@@ -1218,10 +1218,10 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueWaitIdle(XGL_QUEUE queue)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitIdle(VK_QUEUE queue)
{
- XGL_RESULT result = nextTable.QueueWaitIdle(queue);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.QueueWaitIdle(queue);
+ if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
retireQueueFences(queue);
loader_platform_thread_unlock_mutex(&globalLock);
@@ -1229,10 +1229,10 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDeviceWaitIdle(XGL_DEVICE device)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDeviceWaitIdle(VK_DEVICE device)
{
- XGL_RESULT result = nextTable.DeviceWaitIdle(device);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.DeviceWaitIdle(device);
+ if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
retireDeviceFences(device);
loader_platform_thread_unlock_mutex(&globalLock);
@@ -1240,200 +1240,200 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateEvent(XGL_DEVICE device, const XGL_EVENT_CREATE_INFO* pCreateInfo, XGL_EVENT* pEvent)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateEvent(VK_DEVICE device, const VK_EVENT_CREATE_INFO* pCreateInfo, VK_EVENT* pEvent)
{
- XGL_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent);
+ if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pEvent, pCreateInfo->sType, pCreateInfo, sizeof(XGL_EVENT_CREATE_INFO), "event");
+ addObjectInfo(*pEvent, pCreateInfo->sType, pCreateInfo, sizeof(VK_EVENT_CREATE_INFO), "event");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateQueryPool(XGL_DEVICE device, const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo, XGL_QUERY_POOL* pQueryPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateQueryPool(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool)
{
- XGL_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool);
+ if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pQueryPool, pCreateInfo->sType, pCreateInfo, sizeof(XGL_QUERY_POOL_CREATE_INFO), "query_pool");
+ addObjectInfo(*pQueryPool, pCreateInfo->sType, pCreateInfo, sizeof(VK_QUERY_POOL_CREATE_INFO), "query_pool");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateBuffer(XGL_DEVICE device, const XGL_BUFFER_CREATE_INFO* pCreateInfo, XGL_BUFFER* pBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer)
{
- XGL_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer);
+ if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pBuffer, pCreateInfo->sType, pCreateInfo, sizeof(XGL_BUFFER_CREATE_INFO), "buffer");
+ addObjectInfo(*pBuffer, pCreateInfo->sType, pCreateInfo, sizeof(VK_BUFFER_CREATE_INFO), "buffer");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateBufferView(XGL_DEVICE device, const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo, XGL_BUFFER_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView)
{
- XGL_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
- if (result == XGL_SUCCESS) {
+ VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
+ if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(XGL_BUFFER_VIEW_CREATE_INFO), "buffer_view");
+ addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VK_BUFFER_VIEW_CREATE_INFO), "buffer_view");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImage(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage)
{
- XGL_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage);
- if (XGL_SUCCESS == result) {
+ VK_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage);
+ if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pImage, pCreateInfo->sType, pCreateInfo, sizeof(XGL_IMAGE_CREATE_INFO), "image");
+ addObjectInfo(*pImage, pCreateInfo->sType, pCreateInfo, sizeof(VK_IMAGE_CREATE_INFO), "image");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImageView(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView)
{
- XGL_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
- if (result == XGL_SUCCESS) {
+ VK_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
+ if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(XGL_IMAGE_VIEW_CREATE_INFO), "image_view");
+ addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VK_IMAGE_VIEW_CREATE_INFO), "image_view");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateColorAttachmentView(XGL_DEVICE device, const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
- XGL_COLOR_ATTACHMENT_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
+ VK_COLOR_ATTACHMENT_VIEW* pView)
{
- XGL_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView);
- if (result == XGL_SUCCESS) {
+ VK_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView);
+ if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO), "color_attachment_view");
+ addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO), "color_attachment_view");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDepthStencilView(XGL_DEVICE device, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(VK_DEVICE device, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, VK_DEPTH_STENCIL_VIEW* pView)
{
- XGL_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView);
- if (result == XGL_SUCCESS) {
+ VK_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView);
+ if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO), "ds_view");
+ addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VK_DEPTH_STENCIL_VIEW_CREATE_INFO), "ds_view");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateShader(XGL_DEVICE device, const XGL_SHADER_CREATE_INFO* pCreateInfo, XGL_SHADER* pShader)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateShader(VK_DEVICE device, const VK_SHADER_CREATE_INFO* pCreateInfo, VK_SHADER* pShader)
{
- XGL_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader);
+ VK_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline)
{
- XGL_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
- if (result == XGL_SUCCESS) {
+ VK_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+ if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO), "graphics_pipeline");
+ addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VK_GRAPHICS_PIPELINE_CREATE_INFO), "graphics_pipeline");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(
- XGL_DEVICE device,
- const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
- XGL_PIPELINE basePipeline,
- XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative(
+ VK_DEVICE device,
+ const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+ VK_PIPELINE basePipeline,
+ VK_PIPELINE* pPipeline)
{
- XGL_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
- if (result == XGL_SUCCESS) {
+ VK_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
+ if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO), "graphics_pipeline");
+ addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VK_GRAPHICS_PIPELINE_CREATE_INFO), "graphics_pipeline");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(VK_DEVICE device, const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline)
{
- XGL_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
- if (result == XGL_SUCCESS) {
+ VK_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
+ if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO), "compute_pipeline");
+ addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VK_COMPUTE_PIPELINE_CREATE_INFO), "compute_pipeline");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateSampler(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler)
{
- XGL_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
- if (result == XGL_SUCCESS) {
+ VK_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
+ if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pSampler, pCreateInfo->sType, pCreateInfo, sizeof(XGL_SAMPLER_CREATE_INFO), "sampler");
+ addObjectInfo(*pSampler, pCreateInfo->sType, pCreateInfo, sizeof(VK_SAMPLER_CREATE_INFO), "sampler");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicViewportState(XGL_DEVICE device, const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo,
- XGL_DYNAMIC_VP_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo,
+ VK_DYNAMIC_VP_STATE_OBJECT* pState)
{
- XGL_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
- if (result == XGL_SUCCESS) {
+ VK_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
+ if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO), "viewport_state");
+ addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VK_DYNAMIC_VP_STATE_CREATE_INFO), "viewport_state");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicRasterState(XGL_DEVICE device, const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo,
- XGL_DYNAMIC_RS_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo,
+ VK_DYNAMIC_RS_STATE_OBJECT* pState)
{
- XGL_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
- if (result == XGL_SUCCESS) {
+ VK_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
+ if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO), "raster_state");
+ addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VK_DYNAMIC_RS_STATE_CREATE_INFO), "raster_state");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicColorBlendState(XGL_DEVICE device, const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo,
- XGL_DYNAMIC_CB_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo,
+ VK_DYNAMIC_CB_STATE_OBJECT* pState)
{
- XGL_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
- if (result == XGL_SUCCESS) {
+ VK_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
+ if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(XGL_DYNAMIC_CB_STATE_CREATE_INFO), "cb_state");
+ addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VK_DYNAMIC_CB_STATE_CREATE_INFO), "cb_state");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState(XGL_DEVICE device, const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo,
- XGL_DYNAMIC_DS_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo,
+ VK_DYNAMIC_DS_STATE_OBJECT* pState)
{
- XGL_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
- if (result == XGL_SUCCESS) {
+ VK_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
+ if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(XGL_DYNAMIC_DS_STATE_CREATE_INFO), "ds_state");
+ addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VK_DYNAMIC_DS_STATE_CREATE_INFO), "ds_state");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateCommandBuffer(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer)
{
- XGL_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+ VK_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
// At time of cmd buffer creation, create global cmd buffer info for the returned cmd buffer
loader_platform_thread_lock_mutex(&globalLock);
if (*pCmdBuffer)
@@ -1443,54 +1443,54 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginCommandBuffer(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
{
// This implicitly resets the Cmd Buffer so make sure any fence is done and then clear memory references
MT_CB_INFO* pCBInfo = getCBInfo(cmdBuffer);
if (pCBInfo && (!fenceRetired(pCBInfo->fenceId))) {
bool32_t cbDone = checkCBCompleted(cmdBuffer);
- if (XGL_FALSE == cbDone) {
+ if (VK_FALSE == cbDone) {
char str[1024];
- sprintf(str, "Calling xglBeginCommandBuffer() on active CB %p before it has completed. You must check CB flag before this call.", cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
+ sprintf(str, "Calling vkBeginCommandBuffer() on active CB %p before it has completed. You must check CB flag before this call.", cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
}
}
- XGL_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
+ VK_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
loader_platform_thread_lock_mutex(&globalLock);
freeCBBindings(cmdBuffer);
loader_platform_thread_unlock_mutex(&globalLock);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEndCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer)
{
// TODO : Anything to do here?
- XGL_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
+ VK_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer)
{
// Verify that CB is complete (not in-flight)
MT_CB_INFO* pCBInfo = getCBInfo(cmdBuffer);
if (pCBInfo && (!fenceRetired(pCBInfo->fenceId))) {
bool32_t cbDone = checkCBCompleted(cmdBuffer);
- if (XGL_FALSE == cbDone) {
+ if (VK_FALSE == cbDone) {
char str[1024];
- sprintf(str, "Resetting CB %p before it has completed. You must check CB flag before calling xglResetCommandBuffer().", cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
+ sprintf(str, "Resetting CB %p before it has completed. You must check CB flag before calling vkResetCommandBuffer().", cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
}
}
// Clear memory references as this point.
loader_platform_thread_lock_mutex(&globalLock);
freeCBBindings(cmdBuffer);
loader_platform_thread_unlock_mutex(&globalLock);
- XGL_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
+ VK_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
return result;
}
-// TODO : For any xglCmdBind* calls that include an object which has mem bound to it,
+// TODO : For any vkCmdBind* calls that include an object which has mem bound to it,
// need to account for that mem now having binding to given cmdBuffer
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindPipeline(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline)
+VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline)
{
#if 0
// TODO : If memory bound to pipeline, then need to tie that mem to cmdBuffer
@@ -1501,19 +1501,19 @@
} else {
char str[1024];
sprintf(str, "Attempt to bind Pipeline %p to non-existant command buffer %p!", (void*)pipeline, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_INVALID_CB, (char *) "DS", (char *) str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_INVALID_CB, (char *) "DS", (char *) str);
}
}
else {
char str[1024];
sprintf(str, "Attempt to bind Pipeline %p that doesn't exist!", (void*)pipeline);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pipeline, 0, MEMTRACK_INVALID_OBJECT, (char *) "DS", (char *) str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pipeline, 0, MEMTRACK_INVALID_OBJECT, (char *) "DS", (char *) str);
}
#endif
nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDynamicStateObject(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state)
{
MT_OBJ_INFO *pObjInfo;
loader_platform_thread_lock_mutex(&globalLock);
@@ -1521,330 +1521,330 @@
if (!pCmdBuf) {
char str[1024];
sprintf(str, "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_INVALID_CB, "DD", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_INVALID_CB, "DD", str);
}
pObjInfo = getObjectInfo(state);
if (!pObjInfo) {
char str[1024];
sprintf(str, "Unable to find dynamic state object %p, was it ever created?", (void*)state);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, state, 0, MEMTRACK_INVALID_OBJECT, "DD", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, state, 0, MEMTRACK_INVALID_OBJECT, "DD", str);
}
pCmdBuf->pDynamicState[stateBindPoint] = pObjInfo;
loader_platform_thread_unlock_mutex(&globalLock);
nextTable.CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDescriptorSets(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain,
+VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_PIPELINE_BIND_POINT pipelineBindPoint,
+ VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain,
uint32_t layoutChainSlot,
uint32_t count,
- const XGL_DESCRIPTOR_SET* pDescriptorSets,
+ const VK_DESCRIPTOR_SET* pDescriptorSets,
const uint32_t* pUserData)
{
// TODO : Somewhere need to verify that all textures referenced by shaders in DS are in some type of *SHADER_READ* state
nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindVertexBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t binding)
+VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding)
{
nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindIndexBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType)
+VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType)
{
nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride)
{
loader_platform_thread_lock_mutex(&globalLock);
- XGL_GPU_MEMORY mem = getMemBindingFromObject(buffer);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ VK_GPU_MEMORY mem = getMemBindingFromObject(buffer);
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdDrawIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdDrawIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndexedIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride)
{
loader_platform_thread_lock_mutex(&globalLock);
- XGL_GPU_MEMORY mem = getMemBindingFromObject(buffer);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ VK_GPU_MEMORY mem = getMemBindingFromObject(buffer);
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdDrawIndexedIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdDrawIndexedIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDispatchIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset)
{
loader_platform_thread_lock_mutex(&globalLock);
- XGL_GPU_MEMORY mem = getMemBindingFromObject(buffer);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ VK_GPU_MEMORY mem = getMemBindingFromObject(buffer);
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdDispatchIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdDispatchIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_BUFFER destBuffer,
- uint32_t regionCount, const XGL_BUFFER_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer,
+ uint32_t regionCount, const VK_BUFFER_COPY* pRegions)
{
loader_platform_thread_lock_mutex(&globalLock);
- XGL_GPU_MEMORY mem = getMemBindingFromObject(srcBuffer);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ VK_GPU_MEMORY mem = getMemBindingFromObject(srcBuffer);
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdCopyBuffer() call unable to update binding of srcBuffer %p to cmdBuffer %p", srcBuffer, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdCopyBuffer() call unable to update binding of srcBuffer %p to cmdBuffer %p", srcBuffer, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
mem = getMemBindingFromObject(destBuffer);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdCopyBuffer() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdCopyBuffer() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImage(XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
- XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
- uint32_t regionCount, const XGL_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout,
+ VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout,
+ uint32_t regionCount, const VK_IMAGE_COPY* pRegions)
{
// TODO : Each image will have mem mapping so track them
nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBlitImage(XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
- XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
- uint32_t regionCount, const XGL_IMAGE_BLIT* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout,
+ VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout,
+ uint32_t regionCount, const VK_IMAGE_BLIT* pRegions)
{
// TODO : Each image will have mem mapping so track them
nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBufferToImage(XGL_CMD_BUFFER cmdBuffer,
- XGL_BUFFER srcBuffer,
- XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
- uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer,
+ VK_BUFFER srcBuffer,
+ VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout,
+ uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions)
{
// TODO : Track this
loader_platform_thread_lock_mutex(&globalLock);
- XGL_GPU_MEMORY mem = getMemBindingFromObject(destImage);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ VK_GPU_MEMORY mem = getMemBindingFromObject(destImage);
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdCopyMemoryToImage() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdCopyMemoryToImage() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
mem = getMemBindingFromObject(srcBuffer);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdCopyMemoryToImage() call unable to update binding of srcBuffer %p to cmdBuffer %p", srcBuffer, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdCopyMemoryToImage() call unable to update binding of srcBuffer %p to cmdBuffer %p", srcBuffer, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImageToBuffer(XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
- XGL_BUFFER destBuffer,
- uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout,
+ VK_BUFFER destBuffer,
+ uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions)
{
// TODO : Track this
loader_platform_thread_lock_mutex(&globalLock);
- XGL_GPU_MEMORY mem = getMemBindingFromObject(srcImage);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ VK_GPU_MEMORY mem = getMemBindingFromObject(srcImage);
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdCopyImageToMemory() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdCopyImageToMemory() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
mem = getMemBindingFromObject(destBuffer);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdCopyImageToMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdCopyImageToMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCloneImageData(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
- XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout)
+VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout,
+ VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout)
{
// TODO : Each image will have mem mapping so track them
loader_platform_thread_lock_mutex(&globalLock);
- XGL_GPU_MEMORY mem = getMemBindingFromObject(srcImage);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ VK_GPU_MEMORY mem = getMemBindingFromObject(srcImage);
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdCloneImageData() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdCloneImageData() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
mem = getMemBindingFromObject(destImage);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdCloneImageData() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdCloneImageData() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdUpdateBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData)
{
loader_platform_thread_lock_mutex(&globalLock);
- XGL_GPU_MEMORY mem = getMemBindingFromObject(destBuffer);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ VK_GPU_MEMORY mem = getMemBindingFromObject(destBuffer);
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdUpdateMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdUpdateMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdFillBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, uint32_t data)
+VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data)
{
loader_platform_thread_lock_mutex(&globalLock);
- XGL_GPU_MEMORY mem = getMemBindingFromObject(destBuffer);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ VK_GPU_MEMORY mem = getMemBindingFromObject(destBuffer);
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdFillMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdFillMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearColorImage(XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout,
- XGL_CLEAR_COLOR color,
- uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout,
+ VK_CLEAR_COLOR color,
+ uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
{
- // TODO : Verify memory is in XGL_IMAGE_STATE_CLEAR state
+ // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
loader_platform_thread_lock_mutex(&globalLock);
- XGL_GPU_MEMORY mem = getMemBindingFromObject(image);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ VK_GPU_MEMORY mem = getMemBindingFromObject(image);
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdClearColorImage() call unable to update binding of image buffer %p to cmdBuffer %p", image, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdClearColorImage() call unable to update binding of image buffer %p to cmdBuffer %p", image, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearDepthStencil(XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout,
+VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout,
float depth, uint32_t stencil,
- uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+ uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
{
- // TODO : Verify memory is in XGL_IMAGE_STATE_CLEAR state
+ // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
loader_platform_thread_lock_mutex(&globalLock);
- XGL_GPU_MEMORY mem = getMemBindingFromObject(image);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ VK_GPU_MEMORY mem = getMemBindingFromObject(image);
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdClearDepthStencil() call unable to update binding of image buffer %p to cmdBuffer %p", image, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdClearDepthStencil() call unable to update binding of image buffer %p to cmdBuffer %p", image, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdResolveImage(XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
- XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
- uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects)
+VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout,
+ VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout,
+ uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects)
{
loader_platform_thread_lock_mutex(&globalLock);
- XGL_GPU_MEMORY mem = getMemBindingFromObject(srcImage);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ VK_GPU_MEMORY mem = getMemBindingFromObject(srcImage);
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdResolveImage() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdResolveImage() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
mem = getMemBindingFromObject(destImage);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdResolveImage() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdResolveImage() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot, XGL_FLAGS flags)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags)
{
loader_platform_thread_lock_mutex(&globalLock);
- XGL_GPU_MEMORY mem = getMemBindingFromObject(queryPool);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ VK_GPU_MEMORY mem = getMemBindingFromObject(queryPool);
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdBeginQuery() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdBeginQuery() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdEndQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot)
+VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot)
{
loader_platform_thread_lock_mutex(&globalLock);
- XGL_GPU_MEMORY mem = getMemBindingFromObject(queryPool);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ VK_GPU_MEMORY mem = getMemBindingFromObject(queryPool);
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdEndQuery() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdEndQuery() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
nextTable.CmdEndQuery(cmdBuffer, queryPool, slot);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdResetQueryPool(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount)
+VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount)
{
loader_platform_thread_lock_mutex(&globalLock);
- XGL_GPU_MEMORY mem = getMemBindingFromObject(queryPool);
- if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
+ VK_GPU_MEMORY mem = getMemBindingFromObject(queryPool);
+ if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) {
char str[1024];
- sprintf(str, "In xglCmdResetQueryPool() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkCmdResetQueryPool() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
{
// This layer intercepts callbacks
- XGL_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (XGL_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(XGL_LAYER_DBG_FUNCTION_NODE));
+ VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE));
if (!pNewDbgFuncNode)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;
pNewDbgFuncNode->pUserData = pUserData;
pNewDbgFuncNode->pNext = g_pDbgFunctionHead;
g_pDbgFunctionHead = pNewDbgFuncNode;
// force callbacks if DebugAction hasn't been set already other than initial value
if (g_actionIsDefault) {
- g_debugAction = XGL_DBG_LAYER_ACTION_CALLBACK;
+ g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK;
}
- XGL_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
+ VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
{
- XGL_LAYER_DBG_FUNCTION_NODE *pInfo = g_pDbgFunctionHead;
- XGL_LAYER_DBG_FUNCTION_NODE *pPrev = pInfo;
+ VK_LAYER_DBG_FUNCTION_NODE *pInfo = g_pDbgFunctionHead;
+ VK_LAYER_DBG_FUNCTION_NODE *pPrev = pInfo;
while (pInfo) {
if (pInfo->pfnMsgCallback == pfnMsgCallback) {
pPrev->pNext = pInfo->pNext;
@@ -1859,29 +1859,29 @@
if (g_pDbgFunctionHead == NULL)
{
if (g_actionIsDefault) {
- g_debugAction = XGL_DBG_LAYER_ACTION_LOG_MSG;
+ g_debugAction = VK_DBG_LAYER_ACTION_LOG_MSG;
} else {
- g_debugAction = (XGL_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)XGL_DBG_LAYER_ACTION_CALLBACK));
+ g_debugAction = (VK_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)VK_DBG_LAYER_ACTION_CALLBACK));
}
}
- XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
+ VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
return result;
}
#if !defined(WIN32)
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11CreatePresentableImage(XGL_DEVICE device, const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo,
- XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11CreatePresentableImage(VK_DEVICE device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo,
+ VK_IMAGE* pImage, VK_GPU_MEMORY* pMem)
{
- XGL_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
+ VK_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
loader_platform_thread_lock_mutex(&globalLock);
- if (XGL_SUCCESS == result) {
+ if (VK_SUCCESS == result) {
// Add image object, then insert the new Mem Object and then bind it to created image
- addObjectInfo(*pImage, _XGL_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, sizeof(XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO), "wsi_x11_image");
+ addObjectInfo(*pImage, _VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, sizeof(VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO), "wsi_x11_image");
addMemObjInfo(*pMem, NULL);
- if (XGL_FALSE == updateObjectBinding(*pImage, *pMem)) {
+ if (VK_FALSE == updateObjectBinding(*pImage, *pMem)) {
char str[1024];
- sprintf(str, "In xglWsiX11CreatePresentableImage(), unable to set image %p binding to mem obj %p", (void*)*pImage, (void*)*pMem);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, *pImage, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ sprintf(str, "In vkWsiX11CreatePresentableImage(), unable to set image %p binding to mem obj %p", (void*)*pImage, (void*)*pMem);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, *pImage, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
}
printObjList();
@@ -1890,179 +1890,179 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11QueuePresent(XGL_QUEUE queue, const XGL_WSI_X11_PRESENT_INFO* pPresentInfo, XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11QueuePresent(VK_QUEUE queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VK_FENCE fence)
{
loader_platform_thread_lock_mutex(&globalLock);
addFenceInfo(fence, queue);
char str[1024];
- sprintf(str, "In xglWsiX11QueuePresent(), checking queue %p for fence %p", queue, fence);
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_NONE, "MEM", str);
+ sprintf(str, "In vkWsiX11QueuePresent(), checking queue %p for fence %p", queue, fence);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_NONE, "MEM", str);
loader_platform_thread_unlock_mutex(&globalLock);
- XGL_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
+ VK_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
return result;
}
#endif // WIN32
-XGL_LAYER_EXPORT void* XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* funcName)
+VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
if (gpu == NULL)
return NULL;
pCurObj = gpuw;
loader_platform_thread_once(&g_initOnce, initMemTracker);
- if (!strcmp(funcName, "xglGetProcAddr"))
- return (void *) xglGetProcAddr;
- if (!strcmp(funcName, "xglCreateDevice"))
- return (void*) xglCreateDevice;
- if (!strcmp(funcName, "xglDestroyDevice"))
- return (void*) xglDestroyDevice;
- if (!strcmp(funcName, "xglGetExtensionSupport"))
- return (void*) xglGetExtensionSupport;
- if (!strcmp(funcName, "xglEnumerateLayers"))
- return (void*) xglEnumerateLayers;
- if (!strcmp(funcName, "xglQueueSubmit"))
- return (void*) xglQueueSubmit;
- if (!strcmp(funcName, "xglAllocMemory"))
- return (void*) xglAllocMemory;
- if (!strcmp(funcName, "xglFreeMemory"))
- return (void*) xglFreeMemory;
- if (!strcmp(funcName, "xglSetMemoryPriority"))
- return (void*) xglSetMemoryPriority;
- if (!strcmp(funcName, "xglMapMemory"))
- return (void*) xglMapMemory;
- if (!strcmp(funcName, "xglUnmapMemory"))
- return (void*) xglUnmapMemory;
- if (!strcmp(funcName, "xglPinSystemMemory"))
- return (void*) xglPinSystemMemory;
- if (!strcmp(funcName, "xglOpenSharedMemory"))
- return (void*) xglOpenSharedMemory;
- if (!strcmp(funcName, "xglOpenPeerMemory"))
- return (void*) xglOpenPeerMemory;
- if (!strcmp(funcName, "xglOpenPeerImage"))
- return (void*) xglOpenPeerImage;
- if (!strcmp(funcName, "xglDestroyObject"))
- return (void*) xglDestroyObject;
- if (!strcmp(funcName, "xglGetObjectInfo"))
- return (void*) xglGetObjectInfo;
- if (!strcmp(funcName, "xglBindObjectMemory"))
- return (void*) xglBindObjectMemory;
- if (!strcmp(funcName, "xglCreateFence"))
- return (void*) xglCreateFence;
- if (!strcmp(funcName, "xglGetFenceStatus"))
- return (void*) xglGetFenceStatus;
- if (!strcmp(funcName, "xglResetFences"))
- return (void*) xglResetFences;
- if (!strcmp(funcName, "xglWaitForFences"))
- return (void*) xglWaitForFences;
- if (!strcmp(funcName, "xglQueueWaitIdle"))
- return (void*) xglQueueWaitIdle;
- if (!strcmp(funcName, "xglDeviceWaitIdle"))
- return (void*) xglDeviceWaitIdle;
- if (!strcmp(funcName, "xglCreateEvent"))
- return (void*) xglCreateEvent;
- if (!strcmp(funcName, "xglCreateQueryPool"))
- return (void*) xglCreateQueryPool;
- if (!strcmp(funcName, "xglCreateBuffer"))
- return (void*) xglCreateBuffer;
- if (!strcmp(funcName, "xglCreateBufferView"))
- return (void*) xglCreateBufferView;
- if (!strcmp(funcName, "xglCreateImage"))
- return (void*) xglCreateImage;
- if (!strcmp(funcName, "xglCreateImageView"))
- return (void*) xglCreateImageView;
- if (!strcmp(funcName, "xglCreateColorAttachmentView"))
- return (void*) xglCreateColorAttachmentView;
- if (!strcmp(funcName, "xglCreateDepthStencilView"))
- return (void*) xglCreateDepthStencilView;
- if (!strcmp(funcName, "xglCreateShader"))
- return (void*) xglCreateShader;
- if (!strcmp(funcName, "xglCreateGraphicsPipeline"))
- return (void*) xglCreateGraphicsPipeline;
- if (!strcmp(funcName, "xglCreateGraphicsPipelineDerivative"))
- return (void*) xglCreateGraphicsPipelineDerivative;
- if (!strcmp(funcName, "xglCreateComputePipeline"))
- return (void*) xglCreateComputePipeline;
- if (!strcmp(funcName, "xglCreateSampler"))
- return (void*) xglCreateSampler;
- if (!strcmp(funcName, "xglCreateDynamicViewportState"))
- return (void*) xglCreateDynamicViewportState;
- if (!strcmp(funcName, "xglCreateDynamicRasterState"))
- return (void*) xglCreateDynamicRasterState;
- if (!strcmp(funcName, "xglCreateDynamicColorBlendState"))
- return (void*) xglCreateDynamicColorBlendState;
- if (!strcmp(funcName, "xglCreateDynamicDepthStencilState"))
- return (void*) xglCreateDynamicDepthStencilState;
- if (!strcmp(funcName, "xglCreateCommandBuffer"))
- return (void*) xglCreateCommandBuffer;
- if (!strcmp(funcName, "xglBeginCommandBuffer"))
- return (void*) xglBeginCommandBuffer;
- if (!strcmp(funcName, "xglEndCommandBuffer"))
- return (void*) xglEndCommandBuffer;
- if (!strcmp(funcName, "xglResetCommandBuffer"))
- return (void*) xglResetCommandBuffer;
- if (!strcmp(funcName, "xglCmdBindPipeline"))
- return (void*) xglCmdBindPipeline;
- if (!strcmp(funcName, "xglCmdBindDynamicStateObject"))
- return (void*) xglCmdBindDynamicStateObject;
- if (!strcmp(funcName, "xglCmdBindDescriptorSets"))
- return (void*) xglCmdBindDescriptorSets;
- if (!strcmp(funcName, "xglCmdBindVertexBuffer"))
- return (void*) xglCmdBindVertexBuffer;
- if (!strcmp(funcName, "xglCmdBindIndexBuffer"))
- return (void*) xglCmdBindIndexBuffer;
- if (!strcmp(funcName, "xglCmdDrawIndirect"))
- return (void*) xglCmdDrawIndirect;
- if (!strcmp(funcName, "xglCmdDrawIndexedIndirect"))
- return (void*) xglCmdDrawIndexedIndirect;
- if (!strcmp(funcName, "xglCmdDispatchIndirect"))
- return (void*) xglCmdDispatchIndirect;
- if (!strcmp(funcName, "xglCmdCopyBuffer"))
- return (void*) xglCmdCopyBuffer;
- if (!strcmp(funcName, "xglCmdCopyImage"))
- return (void*) xglCmdCopyImage;
- if (!strcmp(funcName, "xglCmdCopyBufferToImage"))
- return (void*) xglCmdCopyBufferToImage;
- if (!strcmp(funcName, "xglCmdCopyImageToBuffer"))
- return (void*) xglCmdCopyImageToBuffer;
- if (!strcmp(funcName, "xglCmdCloneImageData"))
- return (void*) xglCmdCloneImageData;
- if (!strcmp(funcName, "xglCmdUpdateBuffer"))
- return (void*) xglCmdUpdateBuffer;
- if (!strcmp(funcName, "xglCmdFillBuffer"))
- return (void*) xglCmdFillBuffer;
- if (!strcmp(funcName, "xglCmdClearColorImage"))
- return (void*) xglCmdClearColorImage;
- if (!strcmp(funcName, "xglCmdClearDepthStencil"))
- return (void*) xglCmdClearDepthStencil;
- if (!strcmp(funcName, "xglCmdResolveImage"))
- return (void*) xglCmdResolveImage;
- if (!strcmp(funcName, "xglCmdBeginQuery"))
- return (void*) xglCmdBeginQuery;
- if (!strcmp(funcName, "xglCmdEndQuery"))
- return (void*) xglCmdEndQuery;
- if (!strcmp(funcName, "xglCmdResetQueryPool"))
- return (void*) xglCmdResetQueryPool;
- if (!strcmp(funcName, "xglDbgRegisterMsgCallback"))
- return (void*) xglDbgRegisterMsgCallback;
- if (!strcmp(funcName, "xglDbgUnregisterMsgCallback"))
- return (void*) xglDbgUnregisterMsgCallback;
- if (!strcmp(funcName, "xglGetDeviceQueue"))
- return (void*) xglGetDeviceQueue;
- if (!strcmp(funcName, "xglQueueAddMemReference"))
- return (void*) xglQueueAddMemReference;
- if (!strcmp(funcName, "xglQueueRemoveMemReference"))
- return (void*) xglQueueRemoveMemReference;
+ if (!strcmp(funcName, "vkGetProcAddr"))
+ return (void *) vkGetProcAddr;
+ if (!strcmp(funcName, "vkCreateDevice"))
+ return (void*) vkCreateDevice;
+ if (!strcmp(funcName, "vkDestroyDevice"))
+ return (void*) vkDestroyDevice;
+ if (!strcmp(funcName, "vkGetExtensionSupport"))
+ return (void*) vkGetExtensionSupport;
+ if (!strcmp(funcName, "vkEnumerateLayers"))
+ return (void*) vkEnumerateLayers;
+ if (!strcmp(funcName, "vkQueueSubmit"))
+ return (void*) vkQueueSubmit;
+ if (!strcmp(funcName, "vkAllocMemory"))
+ return (void*) vkAllocMemory;
+ if (!strcmp(funcName, "vkFreeMemory"))
+ return (void*) vkFreeMemory;
+ if (!strcmp(funcName, "vkSetMemoryPriority"))
+ return (void*) vkSetMemoryPriority;
+ if (!strcmp(funcName, "vkMapMemory"))
+ return (void*) vkMapMemory;
+ if (!strcmp(funcName, "vkUnmapMemory"))
+ return (void*) vkUnmapMemory;
+ if (!strcmp(funcName, "vkPinSystemMemory"))
+ return (void*) vkPinSystemMemory;
+ if (!strcmp(funcName, "vkOpenSharedMemory"))
+ return (void*) vkOpenSharedMemory;
+ if (!strcmp(funcName, "vkOpenPeerMemory"))
+ return (void*) vkOpenPeerMemory;
+ if (!strcmp(funcName, "vkOpenPeerImage"))
+ return (void*) vkOpenPeerImage;
+ if (!strcmp(funcName, "vkDestroyObject"))
+ return (void*) vkDestroyObject;
+ if (!strcmp(funcName, "vkGetObjectInfo"))
+ return (void*) vkGetObjectInfo;
+ if (!strcmp(funcName, "vkBindObjectMemory"))
+ return (void*) vkBindObjectMemory;
+ if (!strcmp(funcName, "vkCreateFence"))
+ return (void*) vkCreateFence;
+ if (!strcmp(funcName, "vkGetFenceStatus"))
+ return (void*) vkGetFenceStatus;
+ if (!strcmp(funcName, "vkResetFences"))
+ return (void*) vkResetFences;
+ if (!strcmp(funcName, "vkWaitForFences"))
+ return (void*) vkWaitForFences;
+ if (!strcmp(funcName, "vkQueueWaitIdle"))
+ return (void*) vkQueueWaitIdle;
+ if (!strcmp(funcName, "vkDeviceWaitIdle"))
+ return (void*) vkDeviceWaitIdle;
+ if (!strcmp(funcName, "vkCreateEvent"))
+ return (void*) vkCreateEvent;
+ if (!strcmp(funcName, "vkCreateQueryPool"))
+ return (void*) vkCreateQueryPool;
+ if (!strcmp(funcName, "vkCreateBuffer"))
+ return (void*) vkCreateBuffer;
+ if (!strcmp(funcName, "vkCreateBufferView"))
+ return (void*) vkCreateBufferView;
+ if (!strcmp(funcName, "vkCreateImage"))
+ return (void*) vkCreateImage;
+ if (!strcmp(funcName, "vkCreateImageView"))
+ return (void*) vkCreateImageView;
+ if (!strcmp(funcName, "vkCreateColorAttachmentView"))
+ return (void*) vkCreateColorAttachmentView;
+ if (!strcmp(funcName, "vkCreateDepthStencilView"))
+ return (void*) vkCreateDepthStencilView;
+ if (!strcmp(funcName, "vkCreateShader"))
+ return (void*) vkCreateShader;
+ if (!strcmp(funcName, "vkCreateGraphicsPipeline"))
+ return (void*) vkCreateGraphicsPipeline;
+ if (!strcmp(funcName, "vkCreateGraphicsPipelineDerivative"))
+ return (void*) vkCreateGraphicsPipelineDerivative;
+ if (!strcmp(funcName, "vkCreateComputePipeline"))
+ return (void*) vkCreateComputePipeline;
+ if (!strcmp(funcName, "vkCreateSampler"))
+ return (void*) vkCreateSampler;
+ if (!strcmp(funcName, "vkCreateDynamicViewportState"))
+ return (void*) vkCreateDynamicViewportState;
+ if (!strcmp(funcName, "vkCreateDynamicRasterState"))
+ return (void*) vkCreateDynamicRasterState;
+ if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
+ return (void*) vkCreateDynamicColorBlendState;
+ if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
+ return (void*) vkCreateDynamicDepthStencilState;
+ if (!strcmp(funcName, "vkCreateCommandBuffer"))
+ return (void*) vkCreateCommandBuffer;
+ if (!strcmp(funcName, "vkBeginCommandBuffer"))
+ return (void*) vkBeginCommandBuffer;
+ if (!strcmp(funcName, "vkEndCommandBuffer"))
+ return (void*) vkEndCommandBuffer;
+ if (!strcmp(funcName, "vkResetCommandBuffer"))
+ return (void*) vkResetCommandBuffer;
+ if (!strcmp(funcName, "vkCmdBindPipeline"))
+ return (void*) vkCmdBindPipeline;
+ if (!strcmp(funcName, "vkCmdBindDynamicStateObject"))
+ return (void*) vkCmdBindDynamicStateObject;
+ if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
+ return (void*) vkCmdBindDescriptorSets;
+ if (!strcmp(funcName, "vkCmdBindVertexBuffer"))
+ return (void*) vkCmdBindVertexBuffer;
+ if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
+ return (void*) vkCmdBindIndexBuffer;
+ if (!strcmp(funcName, "vkCmdDrawIndirect"))
+ return (void*) vkCmdDrawIndirect;
+ if (!strcmp(funcName, "vkCmdDrawIndexedIndirect"))
+ return (void*) vkCmdDrawIndexedIndirect;
+ if (!strcmp(funcName, "vkCmdDispatchIndirect"))
+ return (void*) vkCmdDispatchIndirect;
+ if (!strcmp(funcName, "vkCmdCopyBuffer"))
+ return (void*) vkCmdCopyBuffer;
+ if (!strcmp(funcName, "vkCmdCopyImage"))
+ return (void*) vkCmdCopyImage;
+ if (!strcmp(funcName, "vkCmdCopyBufferToImage"))
+ return (void*) vkCmdCopyBufferToImage;
+ if (!strcmp(funcName, "vkCmdCopyImageToBuffer"))
+ return (void*) vkCmdCopyImageToBuffer;
+ if (!strcmp(funcName, "vkCmdCloneImageData"))
+ return (void*) vkCmdCloneImageData;
+ if (!strcmp(funcName, "vkCmdUpdateBuffer"))
+ return (void*) vkCmdUpdateBuffer;
+ if (!strcmp(funcName, "vkCmdFillBuffer"))
+ return (void*) vkCmdFillBuffer;
+ if (!strcmp(funcName, "vkCmdClearColorImage"))
+ return (void*) vkCmdClearColorImage;
+ if (!strcmp(funcName, "vkCmdClearDepthStencil"))
+ return (void*) vkCmdClearDepthStencil;
+ if (!strcmp(funcName, "vkCmdResolveImage"))
+ return (void*) vkCmdResolveImage;
+ if (!strcmp(funcName, "vkCmdBeginQuery"))
+ return (void*) vkCmdBeginQuery;
+ if (!strcmp(funcName, "vkCmdEndQuery"))
+ return (void*) vkCmdEndQuery;
+ if (!strcmp(funcName, "vkCmdResetQueryPool"))
+ return (void*) vkCmdResetQueryPool;
+ if (!strcmp(funcName, "vkDbgRegisterMsgCallback"))
+ return (void*) vkDbgRegisterMsgCallback;
+ if (!strcmp(funcName, "vkDbgUnregisterMsgCallback"))
+ return (void*) vkDbgUnregisterMsgCallback;
+ if (!strcmp(funcName, "vkGetDeviceQueue"))
+ return (void*) vkGetDeviceQueue;
+ if (!strcmp(funcName, "vkQueueAddMemReference"))
+ return (void*) vkQueueAddMemReference;
+ if (!strcmp(funcName, "vkQueueRemoveMemReference"))
+ return (void*) vkQueueRemoveMemReference;
#if !defined(WIN32)
- if (!strcmp(funcName, "xglWsiX11CreatePresentableImage"))
- return (void*) xglWsiX11CreatePresentableImage;
- if (!strcmp(funcName, "xglWsiX11QueuePresent"))
- return (void*) xglWsiX11QueuePresent;
+ if (!strcmp(funcName, "vkWsiX11CreatePresentableImage"))
+ return (void*) vkWsiX11CreatePresentableImage;
+ if (!strcmp(funcName, "vkWsiX11QueuePresent"))
+ return (void*) vkWsiX11QueuePresent;
#endif
else {
if (gpuw->pGPA == NULL)
return NULL;
- return gpuw->pGPA((XGL_PHYSICAL_GPU)gpuw->nextObject, funcName);
+ return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName);
}
}
diff --git a/layers/mem_tracker.h b/layers/mem_tracker.h
index 2548036..bb12132 100644
--- a/layers/mem_tracker.h
+++ b/layers/mem_tracker.h
@@ -1,5 +1,5 @@
/*
- * XGL
+ * Vulkan
*
* Copyright (C) 2015 LunarG, Inc.
*
@@ -22,7 +22,7 @@
* DEALINGS IN THE SOFTWARE.
*/
#pragma once
-#include "xglLayer.h"
+#include "vkLayer.h"
#ifdef __cplusplus
extern "C" {
@@ -40,14 +40,14 @@
MEMTRACK_FREED_MEM_REF = 6, // MEM Obj freed while it still has obj and/or CB refs
MEMTRACK_MEM_OBJ_CLEAR_EMPTY_BINDINGS = 7, // Clearing bindings on mem obj that doesn't have any bindings
MEMTRACK_MISSING_MEM_BINDINGS = 8, // Trying to retrieve mem bindings, but none found (may be internal error)
- MEMTRACK_INVALID_OBJECT = 9, // Attempting to reference generic XGL Object that is invalid
- MEMTRACK_FREE_MEM_ERROR = 10, // Error while calling xglFreeMemory
+ MEMTRACK_INVALID_OBJECT = 9, // Attempting to reference generic VK Object that is invalid
+ MEMTRACK_FREE_MEM_ERROR = 10, // Error while calling vkFreeMemory
MEMTRACK_DESTROY_OBJECT_ERROR = 11, // Destroying an object that has a memory reference
MEMTRACK_MEMORY_BINDING_ERROR = 12, // Error during one of many calls that bind memory to object or CB
MEMTRACK_OUT_OF_MEMORY_ERROR = 13, // malloc failed
- MEMTRACK_MEMORY_LEAK = 14, // Failure to call xglFreeMemory on Mem Obj prior to DestroyDevice
+ MEMTRACK_MEMORY_LEAK = 14, // Failure to call vkFreeMemory on Mem Obj prior to DestroyDevice
MEMTRACK_INVALID_STATE = 15, // Memory not in the correct state
- MEMTRACK_RESET_CB_WHILE_IN_FLIGHT = 16, // xglResetCommandBuffer() called on a CB that hasn't completed
+ MEMTRACK_RESET_CB_WHILE_IN_FLIGHT = 16, // vkResetCommandBuffer() called on a CB that hasn't completed
MEMTRACK_INVALID_QUEUE = 17, // Invalid queue requested or selected
MEMTRACK_INVALID_FENCE_STATE = 18, // Invalid Fence State signaled or used
} MEM_TRACK_ERROR;
@@ -61,7 +61,7 @@
* memObjMap -- map of Memory Objects to MT_MEM_OBJ_INFO structures
* Each MT_MEM_OBJ_INFO has two stl list containers with:
* -- all CBs referencing this mem obj
- * -- all XGL Objects that are bound to this memory
+ * -- all VK Objects that are bound to this memory
* objectMap -- map of objects to MT_OBJ_INFO structures
*
* Algorithm overview
@@ -85,31 +85,31 @@
// Data struct for tracking memory object
struct MT_MEM_OBJ_INFO {
uint32_t refCount; // Count of references (obj bindings or CB use)
- XGL_GPU_MEMORY mem;
- XGL_MEMORY_ALLOC_INFO allocInfo;
- list<XGL_OBJECT> pObjBindings; // list container of objects bound to this memory
- list<XGL_CMD_BUFFER> pCmdBufferBindings; // list container of cmd buffers that reference this mem object
+ VK_GPU_MEMORY mem;
+ VK_MEMORY_ALLOC_INFO allocInfo;
+ list<VK_OBJECT> pObjBindings; // list container of objects bound to this memory
+ list<VK_CMD_BUFFER> pCmdBufferBindings; // list container of cmd buffers that reference this mem object
};
struct MT_OBJ_INFO {
MT_MEM_OBJ_INFO* pMemObjInfo;
- XGL_OBJECT object;
- XGL_STRUCTURE_TYPE sType;
+ VK_OBJECT object;
+ VK_STRUCTURE_TYPE sType;
uint32_t ref_count;
// Capture all object types that may have memory bound. From prog guide:
// The only objects that are guaranteed to have no external memory
// requirements are devices, queues, command buffers, shaders and memory objects.
union {
- XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO color_attachment_view_create_info;
- XGL_DEPTH_STENCIL_VIEW_CREATE_INFO ds_view_create_info;
- XGL_IMAGE_VIEW_CREATE_INFO image_view_create_info;
- XGL_IMAGE_CREATE_INFO image_create_info;
- XGL_GRAPHICS_PIPELINE_CREATE_INFO graphics_pipeline_create_info;
- XGL_COMPUTE_PIPELINE_CREATE_INFO compute_pipeline_create_info;
- XGL_SAMPLER_CREATE_INFO sampler_create_info;
- XGL_FENCE_CREATE_INFO fence_create_info;
+ VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO color_attachment_view_create_info;
+ VK_DEPTH_STENCIL_VIEW_CREATE_INFO ds_view_create_info;
+ VK_IMAGE_VIEW_CREATE_INFO image_view_create_info;
+ VK_IMAGE_CREATE_INFO image_create_info;
+ VK_GRAPHICS_PIPELINE_CREATE_INFO graphics_pipeline_create_info;
+ VK_COMPUTE_PIPELINE_CREATE_INFO compute_pipeline_create_info;
+ VK_SAMPLER_CREATE_INFO sampler_create_info;
+ VK_FENCE_CREATE_INFO fence_create_info;
#ifndef _WIN32
- XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO wsi_x11_presentable_image_create_info;
+ VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO wsi_x11_presentable_image_create_info;
#endif // _WIN32
} create_info;
char object_name[64];
@@ -117,21 +117,21 @@
// Track all command buffers
struct MT_CB_INFO {
- XGL_CMD_BUFFER_CREATE_INFO createInfo;
- MT_OBJ_INFO* pDynamicState[XGL_NUM_STATE_BIND_POINT];
- XGL_PIPELINE pipelines[XGL_NUM_PIPELINE_BIND_POINT];
+ VK_CMD_BUFFER_CREATE_INFO createInfo;
+ MT_OBJ_INFO* pDynamicState[VK_NUM_STATE_BIND_POINT];
+ VK_PIPELINE pipelines[VK_NUM_PIPELINE_BIND_POINT];
uint32_t colorAttachmentCount;
- XGL_DEPTH_STENCIL_BIND_INFO dsBindInfo;
- XGL_CMD_BUFFER cmdBuffer;
+ VK_DEPTH_STENCIL_BIND_INFO dsBindInfo;
+ VK_CMD_BUFFER cmdBuffer;
uint64_t fenceId;
// Order dependent, stl containers must be at end of struct
- list<XGL_GPU_MEMORY> pMemObjList; // List container of Mem objs referenced by this CB
+ list<VK_GPU_MEMORY> pMemObjList; // List container of Mem objs referenced by this CB
};
// Associate fenceId with a fence object
struct MT_FENCE_INFO {
- XGL_FENCE fence; // Handle to fence object
- XGL_QUEUE queue; // Queue that this fence is submitted against
+ VK_FENCE fence; // Handle to fence object
+ VK_QUEUE queue; // Queue that this fence is submitted against
bool32_t localFence; // Is fence created by layer?
};
@@ -139,8 +139,8 @@
struct MT_QUEUE_INFO {
uint64_t lastRetiredId;
uint64_t lastSubmittedId;
- list<XGL_CMD_BUFFER> pQueueCmdBuffers;
- list<XGL_GPU_MEMORY> pMemRefList;
+ list<VK_CMD_BUFFER> pQueueCmdBuffers;
+ list<VK_GPU_MEMORY> pMemRefList;
};
#ifdef __cplusplus
diff --git a/layers/multi.cpp b/layers/multi.cpp
index f8c2bc9..a4856eb 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -1,5 +1,5 @@
/*
- * XGL
+ * Vulkan
*
* Copyright (C) 2014 LunarG, Inc.
*
@@ -28,27 +28,27 @@
#include <assert.h>
#include <unordered_map>
#include "loader_platform.h"
-#include "xgl_dispatch_table_helper.h"
-#include "xglLayer.h"
+#include "vk_dispatch_table_helper.h"
+#include "vkLayer.h"
// The following is #included again to catch certain OS-specific functions
// being used:
#include "loader_platform.h"
-static void initLayerTable(const XGL_BASE_LAYER_OBJECT *gpuw, XGL_LAYER_DISPATCH_TABLE *pTable, const unsigned int layerNum);
+static void initLayerTable(const VK_BASE_LAYER_OBJECT *gpuw, VK_LAYER_DISPATCH_TABLE *pTable, const unsigned int layerNum);
/******************************** Layer multi1 functions **************************/
-static std::unordered_map<void *, XGL_LAYER_DISPATCH_TABLE *> tableMap1;
+static std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *> tableMap1;
static bool layer1_first_activated = false;
-static XGL_LAYER_DISPATCH_TABLE * getLayer1Table(const XGL_BASE_LAYER_OBJECT *gpuw)
+static VK_LAYER_DISPATCH_TABLE * getLayer1Table(const VK_BASE_LAYER_OBJECT *gpuw)
{
- XGL_LAYER_DISPATCH_TABLE *pTable;
+ VK_LAYER_DISPATCH_TABLE *pTable;
assert(gpuw);
- std::unordered_map<void *, XGL_LAYER_DISPATCH_TABLE *>::const_iterator it = tableMap1.find((void *) gpuw);
+ std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *>::const_iterator it = tableMap1.find((void *) gpuw);
if (it == tableMap1.end())
{
- pTable = new XGL_LAYER_DISPATCH_TABLE;
+ pTable = new VK_LAYER_DISPATCH_TABLE;
tableMap1[(void *) gpuw] = pTable;
initLayerTable(gpuw, pTable, 1);
return pTable;
@@ -62,98 +62,98 @@
#endif
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi1CreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo,
- XGL_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI multi1CreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo,
+ VK_DEVICE* pDevice)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
- XGL_LAYER_DISPATCH_TABLE* pTable = getLayer1Table(gpuw);
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+ VK_LAYER_DISPATCH_TABLE* pTable = getLayer1Table(gpuw);
- printf("At start of multi1 layer xglCreateDevice()\n");
- XGL_RESULT result = pTable->CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
+ printf("At start of multi1 layer vkCreateDevice()\n");
+ VK_RESULT result = pTable->CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
// create a mapping for the device object into the dispatch table
tableMap1.emplace(*pDevice, pTable);
- printf("Completed multi1 layer xglCreateDevice()\n");
+ printf("Completed multi1 layer vkCreateDevice()\n");
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi1CreateGraphicsPipeline(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
- XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI multi1CreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+ VK_PIPELINE* pPipeline)
{
- XGL_LAYER_DISPATCH_TABLE* pTable = tableMap1[device];
+ VK_LAYER_DISPATCH_TABLE* pTable = tableMap1[device];
- printf("At start of multi1 layer xglCreateGraphicsPipeline()\n");
- XGL_RESULT result = pTable->CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+ printf("At start of multi1 layer vkCreateGraphicsPipeline()\n");
+ VK_RESULT result = pTable->CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
// create a mapping for the pipeline object into the dispatch table
tableMap1.emplace(*pPipeline, pTable);
- printf("Completed multi1 layer xglCreateGraphicsPipeline()\n");
+ printf("Completed multi1 layer vkCreateGraphicsPipeline()\n");
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi1StorePipeline(XGL_PIPELINE pipeline, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI multi1StorePipeline(VK_PIPELINE pipeline, size_t* pDataSize, void* pData)
{
- XGL_LAYER_DISPATCH_TABLE* pTable = tableMap1[pipeline];
+ VK_LAYER_DISPATCH_TABLE* pTable = tableMap1[pipeline];
- printf("At start of multi1 layer xglStorePipeline()\n");
- XGL_RESULT result = pTable->StorePipeline(pipeline, pDataSize, pData);
- printf("Completed multi1 layer xglStorePipeline()\n");
+ printf("At start of multi1 layer vkStorePipeline()\n");
+ VK_RESULT result = pTable->StorePipeline(pipeline, pDataSize, pData);
+ printf("Completed multi1 layer vkStorePipeline()\n");
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi1EnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize,
+VK_LAYER_EXPORT VK_RESULT VKAPI multi1EnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize,
size_t* pOutLayerCount, char* const* pOutLayers,
void* pReserved)
{
if (gpu == NULL)
- return xglEnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+ return vkEnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
- XGL_LAYER_DISPATCH_TABLE* pTable = getLayer1Table(gpuw);
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+ VK_LAYER_DISPATCH_TABLE* pTable = getLayer1Table(gpuw);
- printf("At start of multi1 layer xglEnumerateLayers()\n");
- XGL_RESULT result = pTable->EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
- printf("Completed multi1 layer xglEnumerateLayers()\n");
+ printf("At start of multi1 layer vkEnumerateLayers()\n");
+ VK_RESULT result = pTable->EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+ printf("Completed multi1 layer vkEnumerateLayers()\n");
return result;
}
-XGL_LAYER_EXPORT void * XGLAPI multi1GetProcAddr(XGL_PHYSICAL_GPU gpu, const char* pName)
+VK_LAYER_EXPORT void * VKAPI multi1GetProcAddr(VK_PHYSICAL_GPU gpu, const char* pName)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
if (gpu == NULL)
return NULL;
getLayer1Table(gpuw);
- if (!strncmp("xglCreateDevice", pName, sizeof ("xglCreateDevice")))
+ if (!strncmp("vkCreateDevice", pName, sizeof ("vkCreateDevice")))
return (void *) multi1CreateDevice;
- else if (!strncmp("xglEnumerateLayers", pName, sizeof ("xglEnumerateLayers")))
+ else if (!strncmp("vkEnumerateLayers", pName, sizeof ("vkEnumerateLayers")))
return (void *) multi1EnumerateLayers;
- else if (!strncmp("xglCreateGraphicsPipeline", pName, sizeof ("xglCreateGraphicsPipeline")))
+ else if (!strncmp("vkCreateGraphicsPipeline", pName, sizeof ("vkCreateGraphicsPipeline")))
return (void *) multi1CreateGraphicsPipeline;
- else if (!strncmp("xglStorePipeline", pName, sizeof ("xglStorePipeline")))
+ else if (!strncmp("vkStorePipeline", pName, sizeof ("vkStorePipeline")))
return (void *) multi1StorePipeline;
- else if (!strncmp("xglGetExtensionSupport", pName, sizeof ("xglGetExtensionSupport")))
- return (void *) xglGetExtensionSupport;
+ else if (!strncmp("vkGetExtensionSupport", pName, sizeof ("vkGetExtensionSupport")))
+ return (void *) vkGetExtensionSupport;
else {
if (gpuw->pGPA == NULL)
return NULL;
- return gpuw->pGPA((XGL_PHYSICAL_GPU) gpuw->nextObject, pName);
+ return gpuw->pGPA((VK_PHYSICAL_GPU) gpuw->nextObject, pName);
}
}
/******************************** Layer multi2 functions **************************/
-static std::unordered_map<void *, XGL_LAYER_DISPATCH_TABLE *> tableMap2;
+static std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *> tableMap2;
static bool layer2_first_activated = false;
-static XGL_LAYER_DISPATCH_TABLE * getLayer2Table(const XGL_BASE_LAYER_OBJECT *gpuw)
+static VK_LAYER_DISPATCH_TABLE * getLayer2Table(const VK_BASE_LAYER_OBJECT *gpuw)
{
- XGL_LAYER_DISPATCH_TABLE *pTable;
+ VK_LAYER_DISPATCH_TABLE *pTable;
assert(gpuw);
- std::unordered_map<void *, XGL_LAYER_DISPATCH_TABLE *>::const_iterator it = tableMap2.find((void *) gpuw);
+ std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *>::const_iterator it = tableMap2.find((void *) gpuw);
if (it == tableMap2.end())
{
- pTable = new XGL_LAYER_DISPATCH_TABLE;
+ pTable = new VK_LAYER_DISPATCH_TABLE;
tableMap2[(void *) gpuw] = pTable;
initLayerTable(gpuw, pTable, 2);
return pTable;
@@ -163,138 +163,138 @@
}
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi2CreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo,
- XGL_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI multi2CreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo,
+ VK_DEVICE* pDevice)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
- XGL_LAYER_DISPATCH_TABLE* pTable = getLayer2Table(gpuw);
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+ VK_LAYER_DISPATCH_TABLE* pTable = getLayer2Table(gpuw);
- printf("At start of multi2 xglCreateDevice()\n");
- XGL_RESULT result = pTable->CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
+ printf("At start of multi2 vkCreateDevice()\n");
+ VK_RESULT result = pTable->CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
// create a mapping for the device object into the dispatch table for layer2
tableMap2.emplace(*pDevice, pTable);
- printf("Completed multi2 layer xglCreateDevice()\n");
+ printf("Completed multi2 layer vkCreateDevice()\n");
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi2CreateCommandBuffer(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
- XGL_CMD_BUFFER* pCmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI multi2CreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo,
+ VK_CMD_BUFFER* pCmdBuffer)
{
- XGL_LAYER_DISPATCH_TABLE* pTable = tableMap2[device];
+ VK_LAYER_DISPATCH_TABLE* pTable = tableMap2[device];
- printf("At start of multi2 layer xglCreateCommandBuffer()\n");
- XGL_RESULT result = pTable->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+ printf("At start of multi2 layer vkCreateCommandBuffer()\n");
+ VK_RESULT result = pTable->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
// create a mapping for CmdBuffer object into the dispatch table for layer 2
tableMap2.emplace(*pCmdBuffer, pTable);
- printf("Completed multi2 layer xglCreateCommandBuffer()\n");
+ printf("Completed multi2 layer vkCreateCommandBuffer()\n");
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi2BeginCommandBuffer(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI multi2BeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
{
- XGL_LAYER_DISPATCH_TABLE* pTable = tableMap2[cmdBuffer];
+ VK_LAYER_DISPATCH_TABLE* pTable = tableMap2[cmdBuffer];
- printf("At start of multi2 layer xglBeginCommandBuffer()\n");
- XGL_RESULT result = pTable->BeginCommandBuffer(cmdBuffer, pBeginInfo);
- printf("Completed multi2 layer xglBeginCommandBuffer()\n");
+ printf("At start of multi2 layer vkBeginCommandBuffer()\n");
+ VK_RESULT result = pTable->BeginCommandBuffer(cmdBuffer, pBeginInfo);
+ printf("Completed multi2 layer vkBeginCommandBuffer()\n");
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi2EnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize,
+VK_LAYER_EXPORT VK_RESULT VKAPI multi2EnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize,
size_t* pOutLayerCount, char* const* pOutLayers,
void* pReserved)
{
if (gpu == NULL)
- return xglEnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+ return vkEnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
- XGL_LAYER_DISPATCH_TABLE* pTable = getLayer2Table(gpuw);
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+ VK_LAYER_DISPATCH_TABLE* pTable = getLayer2Table(gpuw);
- printf("At start of multi2 layer xglEnumerateLayers()\n");
- XGL_RESULT result = pTable->EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
- printf("Completed multi2 layer xglEnumerateLayers()\n");
+ printf("At start of multi2 layer vkEnumerateLayers()\n");
+ VK_RESULT result = pTable->EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+ printf("Completed multi2 layer vkEnumerateLayers()\n");
return result;
}
-XGL_LAYER_EXPORT void * XGLAPI multi2GetProcAddr(XGL_PHYSICAL_GPU gpu, const char* pName)
+VK_LAYER_EXPORT void * VKAPI multi2GetProcAddr(VK_PHYSICAL_GPU gpu, const char* pName)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
if (gpu == NULL)
return NULL;
getLayer2Table(gpuw);
- if (!strncmp("xglCreateDevice", pName, sizeof ("xglCreateDevice")))
+ if (!strncmp("vkCreateDevice", pName, sizeof ("vkCreateDevice")))
return (void *) multi2CreateDevice;
- else if (!strncmp("xglEnumerateLayers", pName, sizeof ("xglEnumerateLayers")))
+ else if (!strncmp("vkEnumerateLayers", pName, sizeof ("vkEnumerateLayers")))
return (void *) multi2EnumerateLayers;
- else if (!strncmp("xglCreateCommandBuffer", pName, sizeof ("xglCreateCommandBuffer")))
+ else if (!strncmp("vkCreateCommandBuffer", pName, sizeof ("vkCreateCommandBuffer")))
return (void *) multi2CreateCommandBuffer;
- else if (!strncmp("xglBeginCommandBuffer", pName, sizeof ("xglBeginCommandBuffer")))
+ else if (!strncmp("vkBeginCommandBuffer", pName, sizeof ("vkBeginCommandBuffer")))
return (void *) multi2BeginCommandBuffer;
- else if (!strncmp("xglGetExtensionSupport", pName, sizeof ("xglGetExtensionSupport")))
- return (void *) xglGetExtensionSupport;
+ else if (!strncmp("vkGetExtensionSupport", pName, sizeof ("vkGetExtensionSupport")))
+ return (void *) vkGetExtensionSupport;
else {
if (gpuw->pGPA == NULL)
return NULL;
- return gpuw->pGPA((XGL_PHYSICAL_GPU) gpuw->nextObject, pName);
+ return gpuw->pGPA((VK_PHYSICAL_GPU) gpuw->nextObject, pName);
}
}
/********************************* Common functions ********************************/
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize,
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize,
size_t* pOutLayerCount, char* const* pOutLayers,
void* pReserved)
{
if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL || pOutLayers[1] == NULL || pReserved == NULL)
- return XGL_ERROR_INVALID_POINTER;
+ return VK_ERROR_INVALID_POINTER;
if (maxLayerCount < 2)
- return XGL_ERROR_INITIALIZATION_FAILED;
+ return VK_ERROR_INITIALIZATION_FAILED;
*pOutLayerCount = 2;
strncpy((char *) pOutLayers[0], "multi1", maxStringSize);
strncpy((char *) pOutLayers[1], "multi2", maxStringSize);
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu, const char* pExtName)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName)
{
- XGL_RESULT result;
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_RESULT result;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
/* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */
if (!strncmp(pExtName, "multi1", strlen("multi1")))
{
- result = XGL_SUCCESS;
+ result = VK_SUCCESS;
} else if (!strncmp(pExtName, "multi2", strlen("multi2")))
{
- result = XGL_SUCCESS;
+ result = VK_SUCCESS;
} else if (!tableMap1.empty() && (tableMap1.find(gpuw) != tableMap1.end()))
{
- XGL_LAYER_DISPATCH_TABLE* pTable = tableMap1[gpuw];
- result = pTable->GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);
+ VK_LAYER_DISPATCH_TABLE* pTable = tableMap1[gpuw];
+ result = pTable->GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);
} else if (!tableMap2.empty() && (tableMap2.find(gpuw) != tableMap2.end()))
{
- XGL_LAYER_DISPATCH_TABLE* pTable = tableMap2[gpuw];
- result = pTable->GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);
+ VK_LAYER_DISPATCH_TABLE* pTable = tableMap2[gpuw];
+ result = pTable->GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);
} else
{
- result = XGL_ERROR_INVALID_EXTENSION;
+ result = VK_ERROR_INVALID_EXTENSION;
}
return result;
}
-XGL_LAYER_EXPORT void * XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* pName)
+VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* pName)
{
// to find each layers GPA routine Loader will search via "<layerName>GetProcAddr"
if (!strncmp("multi1GetProcAddr", pName, sizeof("multi1GetProcAddr")))
return (void *) multi1GetProcAddr;
else if (!strncmp("multi2GetProcAddr", pName, sizeof("multi2GetProcAddr")))
return (void *) multi2GetProcAddr;
- else if (!strncmp("xglGetProcAddr", pName, sizeof("xglGetProcAddr")))
- return (void *) xglGetProcAddr;
+ else if (!strncmp("vkGetProcAddr", pName, sizeof("vkGetProcAddr")))
+ return (void *) vkGetProcAddr;
// use first layer activated as GPA dispatch table activation happens in order
else if (layer1_first_activated)
@@ -310,12 +310,12 @@
} //extern "C"
#endif
-static void initLayerTable(const XGL_BASE_LAYER_OBJECT *gpuw, XGL_LAYER_DISPATCH_TABLE *pTable, const unsigned int layerNum)
+static void initLayerTable(const VK_BASE_LAYER_OBJECT *gpuw, VK_LAYER_DISPATCH_TABLE *pTable, const unsigned int layerNum)
{
if (layerNum == 2 && layer1_first_activated == false)
layer2_first_activated = true;
if (layerNum == 1 && layer2_first_activated == false)
layer1_first_activated = true;
- layer_initialize_dispatch_table(pTable, gpuw->pGPA, (XGL_PHYSICAL_GPU) gpuw->nextObject);
+ layer_initialize_dispatch_table(pTable, gpuw->pGPA, (VK_PHYSICAL_GPU) gpuw->nextObject);
}
diff --git a/layers/object_track.h b/layers/object_track.h
index 65e1fef..a0050c8 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -1,5 +1,5 @@
/*
- * XGL
+ * Vulkan
*
* Copyright (C) 2014 LunarG, Inc.
*
@@ -22,7 +22,7 @@
* DEALINGS IN THE SOFTWARE.
*/
-#include "xglLayer.h"
+#include "vkLayer.h"
// Object Tracker ERROR codes
typedef enum _OBJECT_TRACK_ERROR
{
@@ -56,109 +56,109 @@
} OBJECT_STATUS;
// TODO : Make this code-generated
// Object type enum
-typedef enum _XGL_OBJECT_TYPE
+typedef enum _VK_OBJECT_TYPE
{
- XGL_OBJECT_TYPE_SAMPLER,
- XGL_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT,
- XGL_OBJECT_TYPE_DESCRIPTOR_SET,
- XGL_OBJECT_TYPE_DESCRIPTOR_POOL,
- XGL_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT,
- XGL_OBJECT_TYPE_IMAGE_VIEW,
- XGL_OBJECT_TYPE_SEMAPHORE,
- XGL_OBJECT_TYPE_SHADER,
- XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
- XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_CHAIN,
- XGL_OBJECT_TYPE_BUFFER,
- XGL_OBJECT_TYPE_PIPELINE,
- XGL_OBJECT_TYPE_DEVICE,
- XGL_OBJECT_TYPE_QUERY_POOL,
- XGL_OBJECT_TYPE_EVENT,
- XGL_OBJECT_TYPE_QUEUE,
- XGL_OBJECT_TYPE_PHYSICAL_GPU,
- XGL_OBJECT_TYPE_RENDER_PASS,
- XGL_OBJECT_TYPE_FRAMEBUFFER,
- XGL_OBJECT_TYPE_IMAGE,
- XGL_OBJECT_TYPE_BUFFER_VIEW,
- XGL_OBJECT_TYPE_DEPTH_STENCIL_VIEW,
- XGL_OBJECT_TYPE_INSTANCE,
- XGL_OBJECT_TYPE_PIPELINE_DELTA,
- XGL_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT,
- XGL_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW,
- XGL_OBJECT_TYPE_GPU_MEMORY,
- XGL_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT,
- XGL_OBJECT_TYPE_FENCE,
- XGL_OBJECT_TYPE_CMD_BUFFER,
- XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY,
+ VK_OBJECT_TYPE_SAMPLER,
+ VK_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT,
+ VK_OBJECT_TYPE_DESCRIPTOR_SET,
+ VK_OBJECT_TYPE_DESCRIPTOR_POOL,
+ VK_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT,
+ VK_OBJECT_TYPE_IMAGE_VIEW,
+ VK_OBJECT_TYPE_SEMAPHORE,
+ VK_OBJECT_TYPE_SHADER,
+ VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
+ VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_CHAIN,
+ VK_OBJECT_TYPE_BUFFER,
+ VK_OBJECT_TYPE_PIPELINE,
+ VK_OBJECT_TYPE_DEVICE,
+ VK_OBJECT_TYPE_QUERY_POOL,
+ VK_OBJECT_TYPE_EVENT,
+ VK_OBJECT_TYPE_QUEUE,
+ VK_OBJECT_TYPE_PHYSICAL_GPU,
+ VK_OBJECT_TYPE_RENDER_PASS,
+ VK_OBJECT_TYPE_FRAMEBUFFER,
+ VK_OBJECT_TYPE_IMAGE,
+ VK_OBJECT_TYPE_BUFFER_VIEW,
+ VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW,
+ VK_OBJECT_TYPE_INSTANCE,
+ VK_OBJECT_TYPE_PIPELINE_DELTA,
+ VK_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT,
+ VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW,
+ VK_OBJECT_TYPE_GPU_MEMORY,
+ VK_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT,
+ VK_OBJECT_TYPE_FENCE,
+ VK_OBJECT_TYPE_CMD_BUFFER,
+ VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY,
- XGL_OBJECT_TYPE_UNKNOWN,
- XGL_NUM_OBJECT_TYPE,
- XGL_OBJECT_TYPE_ANY, // Allow global object list to be queried/retrieved
-} XGL_OBJECT_TYPE;
+ VK_OBJECT_TYPE_UNKNOWN,
+ VK_NUM_OBJECT_TYPE,
+ VK_OBJECT_TYPE_ANY, // Allow global object list to be queried/retrieved
+} VK_OBJECT_TYPE;
-static const char* string_XGL_OBJECT_TYPE(XGL_OBJECT_TYPE type) {
+static const char* string_VK_OBJECT_TYPE(VK_OBJECT_TYPE type) {
switch (type)
{
- case XGL_OBJECT_TYPE_DEVICE:
+ case VK_OBJECT_TYPE_DEVICE:
return "DEVICE";
- case XGL_OBJECT_TYPE_PIPELINE:
+ case VK_OBJECT_TYPE_PIPELINE:
return "PIPELINE";
- case XGL_OBJECT_TYPE_FENCE:
+ case VK_OBJECT_TYPE_FENCE:
return "FENCE";
- case XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
+ case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
return "DESCRIPTOR_SET_LAYOUT";
- case XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_CHAIN:
+ case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_CHAIN:
return "DESCRIPTOR_SET_LAYOUT_CHAIN";
- case XGL_OBJECT_TYPE_GPU_MEMORY:
+ case VK_OBJECT_TYPE_GPU_MEMORY:
return "GPU_MEMORY";
- case XGL_OBJECT_TYPE_QUEUE:
+ case VK_OBJECT_TYPE_QUEUE:
return "QUEUE";
- case XGL_OBJECT_TYPE_IMAGE:
+ case VK_OBJECT_TYPE_IMAGE:
return "IMAGE";
- case XGL_OBJECT_TYPE_CMD_BUFFER:
+ case VK_OBJECT_TYPE_CMD_BUFFER:
return "CMD_BUFFER";
- case XGL_OBJECT_TYPE_SEMAPHORE:
+ case VK_OBJECT_TYPE_SEMAPHORE:
return "SEMAPHORE";
- case XGL_OBJECT_TYPE_FRAMEBUFFER:
+ case VK_OBJECT_TYPE_FRAMEBUFFER:
return "FRAMEBUFFER";
- case XGL_OBJECT_TYPE_SAMPLER:
+ case VK_OBJECT_TYPE_SAMPLER:
return "SAMPLER";
- case XGL_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW:
+ case VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW:
return "COLOR_ATTACHMENT_VIEW";
- case XGL_OBJECT_TYPE_BUFFER_VIEW:
+ case VK_OBJECT_TYPE_BUFFER_VIEW:
return "BUFFER_VIEW";
- case XGL_OBJECT_TYPE_DESCRIPTOR_SET:
+ case VK_OBJECT_TYPE_DESCRIPTOR_SET:
return "DESCRIPTOR_SET";
- case XGL_OBJECT_TYPE_PHYSICAL_GPU:
+ case VK_OBJECT_TYPE_PHYSICAL_GPU:
return "PHYSICAL_GPU";
- case XGL_OBJECT_TYPE_IMAGE_VIEW:
+ case VK_OBJECT_TYPE_IMAGE_VIEW:
return "IMAGE_VIEW";
- case XGL_OBJECT_TYPE_BUFFER:
+ case VK_OBJECT_TYPE_BUFFER:
return "BUFFER";
- case XGL_OBJECT_TYPE_PIPELINE_DELTA:
+ case VK_OBJECT_TYPE_PIPELINE_DELTA:
return "PIPELINE_DELTA";
- case XGL_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT:
+ case VK_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT:
return "DYNAMIC_RS_STATE_OBJECT";
- case XGL_OBJECT_TYPE_EVENT:
+ case VK_OBJECT_TYPE_EVENT:
return "EVENT";
- case XGL_OBJECT_TYPE_DEPTH_STENCIL_VIEW:
+ case VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW:
return "DEPTH_STENCIL_VIEW";
- case XGL_OBJECT_TYPE_SHADER:
+ case VK_OBJECT_TYPE_SHADER:
return "SHADER";
- case XGL_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT:
+ case VK_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT:
return "DYNAMIC_DS_STATE_OBJECT";
- case XGL_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT:
+ case VK_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT:
return "DYNAMIC_VP_STATE_OBJECT";
- case XGL_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT:
+ case VK_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT:
return "DYNAMIC_CB_STATE_OBJECT";
- case XGL_OBJECT_TYPE_INSTANCE:
+ case VK_OBJECT_TYPE_INSTANCE:
return "INSTANCE";
- case XGL_OBJECT_TYPE_RENDER_PASS:
+ case VK_OBJECT_TYPE_RENDER_PASS:
return "RENDER_PASS";
- case XGL_OBJECT_TYPE_QUERY_POOL:
+ case VK_OBJECT_TYPE_QUERY_POOL:
return "QUERY_POOL";
- case XGL_OBJECT_TYPE_DESCRIPTOR_POOL:
+ case VK_OBJECT_TYPE_DESCRIPTOR_POOL:
return "DESCRIPTOR_POOL";
- case XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY:
+ case VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY:
return "PRESENTABLE_IMAGE_MEMORY";
default:
return "UNKNOWN";
@@ -167,15 +167,15 @@
typedef struct _OBJTRACK_NODE {
void *pObj;
- XGL_OBJECT_TYPE objType;
+ VK_OBJECT_TYPE objType;
uint64_t numUses;
OBJECT_STATUS status;
} OBJTRACK_NODE;
// prototype for extension functions
-uint64_t objTrackGetObjectCount(XGL_OBJECT_TYPE type);
-XGL_RESULT objTrackGetObjects(XGL_OBJECT_TYPE type, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray);
+uint64_t objTrackGetObjectCount(VK_OBJECT_TYPE type);
+VK_RESULT objTrackGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray);
// Func ptr typedefs
-typedef uint64_t (*OBJ_TRACK_GET_OBJECT_COUNT)(XGL_OBJECT_TYPE);
-typedef XGL_RESULT (*OBJ_TRACK_GET_OBJECTS)(XGL_OBJECT_TYPE, uint64_t, OBJTRACK_NODE*);
+typedef uint64_t (*OBJ_TRACK_GET_OBJECT_COUNT)(VK_OBJECT_TYPE);
+typedef VK_RESULT (*OBJ_TRACK_GET_OBJECTS)(VK_OBJECT_TYPE, uint64_t, OBJTRACK_NODE*);
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 700dca3..fb1189e 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -1,5 +1,5 @@
/*
- * XGL
+ * Vulkan
*
* Copyright (C) 2014 LunarG, Inc.
*
@@ -31,20 +31,20 @@
#include <sstream>
#include "loader_platform.h"
-#include "xglLayer.h"
+#include "vkLayer.h"
#include "layers_config.h"
-#include "xgl_enum_validate_helper.h"
-#include "xgl_struct_validate_helper.h"
+#include "vk_enum_validate_helper.h"
+#include "vk_struct_validate_helper.h"
//The following is #included again to catch certain OS-specific functions being used:
#include "loader_platform.h"
#include "layers_msg.h"
-static XGL_LAYER_DISPATCH_TABLE nextTable;
-static XGL_BASE_LAYER_OBJECT *pCurObj;
+static VK_LAYER_DISPATCH_TABLE nextTable;
+static VK_BASE_LAYER_OBJECT *pCurObj;
static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);
-#include "xgl_dispatch_table_helper.h"
+#include "vk_dispatch_table_helper.h"
static void initParamChecker(void)
{
@@ -53,7 +53,7 @@
getLayerOptionEnum("ParamCheckerReportLevel", (uint32_t *) &g_reportingLevel);
g_actionIsDefault = getLayerOptionEnum("ParamCheckerDebugAction", (uint32_t *) &g_debugAction);
- if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
+ if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
{
strOpt = getLayerOption("ParamCheckerLogFilename");
if (strOpt)
@@ -64,1547 +64,1548 @@
g_logFile = stdout;
}
- xglGetProcAddrType fpNextGPA;
+ vkGetProcAddrType fpNextGPA;
fpNextGPA = pCurObj->pGPA;
assert(fpNextGPA);
- layer_initialize_dispatch_table(&nextTable, fpNextGPA, (XGL_PHYSICAL_GPU) pCurObj->nextObject);
+ layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject);
}
-void PreCreateInstance(const XGL_APPLICATION_INFO* pAppInfo, const XGL_ALLOC_CALLBACKS* pAllocCb)
+void PreCreateInstance(const VK_APPLICATION_INFO* pAppInfo, const VK_ALLOC_CALLBACKS* pAllocCb)
{
if(pAppInfo == nullptr)
{
- char const str[] = "xglCreateInstance parameter, XGL_APPLICATION_INFO* pAppInfo, is "\
+ char const str[] = "vkCreateInstance parameter, VK_APPLICATION_INFO* pAppInfo, is "\
"nullptr (precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- if(pAppInfo->sType != XGL_STRUCTURE_TYPE_APPLICATION_INFO)
+ if(pAppInfo->sType != VK_STRUCTURE_TYPE_APPLICATION_INFO)
{
- char const str[] = "xglCreateInstance parameter, XGL_STRUCTURE_TYPE_APPLICATION_INFO "\
- "pAppInfo->sType, is not XGL_STRUCTURE_TYPE_APPLICATION_INFO (precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ char const str[] = "vkCreateInstance parameter, VK_STRUCTURE_TYPE_APPLICATION_INFO "\
+ "pAppInfo->sType, is not VK_STRUCTURE_TYPE_APPLICATION_INFO (precondition).";
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
// TODO: What else can validated in pAppInfo?
- // TODO: XGL_API_VERSION validation.
+ // TODO: VK_API_VERSION validation.
// It's okay if pAllocCb is a nullptr.
if(pAllocCb != nullptr)
{
- if(!xgl_validate_xgl_alloc_callbacks(pAllocCb))
+ if(!vk_validate_vk_alloc_callbacks(pAllocCb))
{
- char const str[] = "xglCreateInstance parameter, XGL_ALLOC_CALLBACKS* pAllocCb, "\
+ char const str[] = "vkCreateInstance parameter, VK_ALLOC_CALLBACKS* pAllocCb, "\
"contains an invalid value (precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
}
}
-void PostCreateInstance(XGL_RESULT result, XGL_INSTANCE* pInstance)
+void PostCreateInstance(VK_RESULT result, VK_INSTANCE* pInstance)
{
- if(result != XGL_SUCCESS)
+ if(result != VK_SUCCESS)
{
- // TODO: Spit out XGL_RESULT value.
- char const str[] = "xglCreateInstance failed (postcondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ // TODO: Spit out VK_RESULT value.
+ char const str[] = "vkCreateInstance failed (postcondition).";
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
if(pInstance == nullptr)
{
- char const str[] = "xglCreateInstance parameter, XGL_INSTANCE* pInstance, is nullptr (postcondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ char const str[] = "vkCreateInstance parameter, VK_INSTANCE* pInstance, is nullptr "\
+ "(postcondition).";
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateInstance(const XGL_INSTANCE_CREATE_INFO* pCreateInfo, XGL_INSTANCE* pInstance)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateInstance(const VK_INSTANCE_CREATE_INFO* pCreateInfo, VK_INSTANCE* pInstance)
{
PreCreateInstance(pCreateInfo->pAppInfo, pCreateInfo->pAllocCb);
- XGL_RESULT result = nextTable.CreateInstance(pCreateInfo, pInstance);
+ VK_RESULT result = nextTable.CreateInstance(pCreateInfo, pInstance);
PostCreateInstance(result, pInstance);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyInstance(XGL_INSTANCE instance)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyInstance(VK_INSTANCE instance)
{
- XGL_RESULT result = nextTable.DestroyInstance(instance);
+ VK_RESULT result = nextTable.DestroyInstance(instance);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateGpus(XGL_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, XGL_PHYSICAL_GPU* pGpus)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateGpus(VK_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, VK_PHYSICAL_GPU* pGpus)
{
- XGL_RESULT result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus);
+ VK_RESULT result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetGpuInfo(XGL_PHYSICAL_GPU gpu, XGL_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetGpuInfo(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
pCurObj = gpuw;
loader_platform_thread_once(&tabOnce, initParamChecker);
char str[1024];
- if (!validate_XGL_PHYSICAL_GPU_INFO_TYPE(infoType)) {
+ if (!validate_VK_PHYSICAL_GPU_INFO_TYPE(infoType)) {
sprintf(str, "Parameter infoType to function GetGpuInfo has invalid value of %i.", (int)infoType);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.GetGpuInfo((XGL_PHYSICAL_GPU)gpuw->nextObject, infoType, pDataSize, pData);
+ VK_RESULT result = nextTable.GetGpuInfo((VK_PHYSICAL_GPU)gpuw->nextObject, infoType, pDataSize, pData);
return result;
}
-void PreCreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo)
+void PreCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo)
{
if(gpu == nullptr)
{
- char const str[] = "xglCreateDevice parameter, XGL_PHYSICAL_GPU gpu, is nullptr "\
+ char const str[] = "vkCreateDevice parameter, VK_PHYSICAL_GPU gpu, is nullptr "\
"(precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
if(pCreateInfo == nullptr)
{
- char const str[] = "xglCreateDevice parameter, XGL_DEVICE_CREATE_INFO* pCreateInfo, is "\
+ char const str[] = "vkCreateDevice parameter, VK_DEVICE_CREATE_INFO* pCreateInfo, is "\
"nullptr (precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- if(pCreateInfo->sType != XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO)
+ if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO)
{
- char const str[] = "xglCreateDevice parameter, XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO "\
- "pCreateInfo->sType, is not XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO (precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ char const str[] = "vkCreateDevice parameter, VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO "\
+ "pCreateInfo->sType, is not VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO (precondition).";
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
if(pCreateInfo->queueRecordCount == 0)
{
- char const str[] = "xglCreateDevice parameter, uint32_t pCreateInfo->queueRecordCount, is "\
+ char const str[] = "vkCreateDevice parameter, uint32_t pCreateInfo->queueRecordCount, is "\
"zero (precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
if(pCreateInfo->pRequestedQueues == nullptr)
{
- char const str[] = "xglCreateDevice parameter, XGL_DEVICE_QUEUE_CREATE_INFO* pCreateInfo->pRequestedQueues, is "\
+ char const str[] = "vkCreateDevice parameter, VK_DEVICE_QUEUE_CREATE_INFO* pCreateInfo->pRequestedQueues, is "\
"nullptr (precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
for(uint32_t i = 0; i < pCreateInfo->queueRecordCount; ++i)
{
- if(!xgl_validate_xgl_device_queue_create_info(&(pCreateInfo->pRequestedQueues[i])))
+ if(!vk_validate_vk_device_queue_create_info(&(pCreateInfo->pRequestedQueues[i])))
{
std::stringstream ss;
- ss << "xglCreateDevice parameter, XGL_DEVICE_QUEUE_CREATE_INFO pCreateInfo->pRequestedQueues[" << i <<
+ ss << "vkCreateDevice parameter, VK_DEVICE_QUEUE_CREATE_INFO pCreateInfo->pRequestedQueues[" << i <<
"], is invalid (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
continue;
}
}
- if(!validate_XGL_VALIDATION_LEVEL(pCreateInfo->maxValidationLevel))
+ if(!validate_VK_VALIDATION_LEVEL(pCreateInfo->maxValidationLevel))
{
- char const str[] = "xglCreateDevice parameter, XGL_VALIDATION_LEVEL pCreateInfo->maxValidationLevel, is "\
+ char const str[] = "vkCreateDevice parameter, VK_VALIDATION_LEVEL pCreateInfo->maxValidationLevel, is "\
"unrecognized (precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
}
-void PostCreateDevice(XGL_RESULT result, XGL_DEVICE* pDevice)
+void PostCreateDevice(VK_RESULT result, VK_DEVICE* pDevice)
{
- if(result != XGL_SUCCESS)
+ if(result != VK_SUCCESS)
{
- // TODO: Spit out XGL_RESULT value.
- char const str[] = "xglCreateDevice failed (postcondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ // TODO: Spit out VK_RESULT value.
+ char const str[] = "vkCreateDevice failed (postcondition).";
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
if(pDevice == nullptr)
{
- char const str[] = "xglCreateDevice parameter, XGL_DEVICE* pDevice, is nullptr (postcondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ char const str[] = "vkCreateDevice parameter, VK_DEVICE* pDevice, is nullptr (postcondition).";
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
pCurObj = gpuw;
loader_platform_thread_once(&tabOnce, initParamChecker);
PreCreateDevice(gpu, pCreateInfo);
- XGL_RESULT result = nextTable.CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
+ VK_RESULT result = nextTable.CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
PostCreateDevice(result, pDevice);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyDevice(XGL_DEVICE device)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device)
{
- XGL_RESULT result = nextTable.DestroyDevice(device);
+ VK_RESULT result = nextTable.DestroyDevice(device);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu, const char* pExtName)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
pCurObj = gpuw;
loader_platform_thread_once(&tabOnce, initParamChecker);
- XGL_RESULT result = nextTable.GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);
+ VK_RESULT result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
{
char str[1024];
if (gpu != NULL) {
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
sprintf(str, "At start of layered EnumerateLayers\n");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, nullptr, 0, 0, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, nullptr, 0, 0, "PARAMCHECK", str);
pCurObj = gpuw;
loader_platform_thread_once(&tabOnce, initParamChecker);
- XGL_RESULT result = nextTable.EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+ VK_RESULT result = nextTable.EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
sprintf(str, "Completed layered EnumerateLayers\n");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, nullptr, 0, 0, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, nullptr, 0, 0, "PARAMCHECK", str);
fflush(stdout);
return result;
} else {
if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
- return XGL_ERROR_INVALID_POINTER;
+ return VK_ERROR_INVALID_POINTER;
// This layer compatible with all GPUs
*pOutLayerCount = 1;
strncpy(pOutLayers[0], "ParamChecker", maxStringSize);
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetDeviceQueue(XGL_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, XGL_QUEUE* pQueue)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetDeviceQueue(VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, VK_QUEUE* pQueue)
{
- XGL_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
+ VK_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit(VK_QUEUE queue, uint32_t cmdBufferCount, const VK_CMD_BUFFER* pCmdBuffers, VK_FENCE fence)
{
- XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
+ VK_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueAddMemReference(XGL_QUEUE queue, XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueAddMemReference(VK_QUEUE queue, VK_GPU_MEMORY mem)
{
- XGL_RESULT result = nextTable.QueueAddMemReference(queue, mem);
+ VK_RESULT result = nextTable.QueueAddMemReference(queue, mem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueRemoveMemReference(XGL_QUEUE queue, XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueRemoveMemReference(VK_QUEUE queue, VK_GPU_MEMORY mem)
{
- XGL_RESULT result = nextTable.QueueRemoveMemReference(queue, mem);
+ VK_RESULT result = nextTable.QueueRemoveMemReference(queue, mem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueWaitIdle(XGL_QUEUE queue)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitIdle(VK_QUEUE queue)
{
- XGL_RESULT result = nextTable.QueueWaitIdle(queue);
+ VK_RESULT result = nextTable.QueueWaitIdle(queue);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDeviceWaitIdle(XGL_DEVICE device)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDeviceWaitIdle(VK_DEVICE device)
{
- XGL_RESULT result = nextTable.DeviceWaitIdle(device);
+ VK_RESULT result = nextTable.DeviceWaitIdle(device);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglAllocMemory(XGL_DEVICE device, const XGL_MEMORY_ALLOC_INFO* pAllocInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem)
{
char str[1024];
if (!pAllocInfo) {
sprintf(str, "Struct ptr parameter pAllocInfo to function AllocMemory is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_memory_alloc_info(pAllocInfo)) {
+ else if (!vk_validate_vk_memory_alloc_info(pAllocInfo)) {
sprintf(str, "Parameter pAllocInfo to function AllocMemory contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem);
+ VK_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglFreeMemory(XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkFreeMemory(VK_GPU_MEMORY mem)
{
- XGL_RESULT result = nextTable.FreeMemory(mem);
+ VK_RESULT result = nextTable.FreeMemory(mem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSetMemoryPriority(XGL_GPU_MEMORY mem, XGL_MEMORY_PRIORITY priority)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkSetMemoryPriority(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority)
{
char str[1024];
- if (!validate_XGL_MEMORY_PRIORITY(priority)) {
+ if (!validate_VK_MEMORY_PRIORITY(priority)) {
sprintf(str, "Parameter priority to function SetMemoryPriority has invalid value of %i.", (int)priority);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.SetMemoryPriority(mem, priority);
+ VK_RESULT result = nextTable.SetMemoryPriority(mem, priority);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglMapMemory(XGL_GPU_MEMORY mem, XGL_FLAGS flags, void** ppData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkMapMemory(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData)
{
- XGL_RESULT result = nextTable.MapMemory(mem, flags, ppData);
+ VK_RESULT result = nextTable.MapMemory(mem, flags, ppData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglUnmapMemory(XGL_GPU_MEMORY mem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkUnmapMemory(VK_GPU_MEMORY mem)
{
- XGL_RESULT result = nextTable.UnmapMemory(mem);
+ VK_RESULT result = nextTable.UnmapMemory(mem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglPinSystemMemory(XGL_DEVICE device, const void* pSysMem, size_t memSize, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkPinSystemMemory(VK_DEVICE device, const void* pSysMem, size_t memSize, VK_GPU_MEMORY* pMem)
{
- XGL_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem);
+ VK_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(XGL_PHYSICAL_GPU gpu0, XGL_PHYSICAL_GPU gpu1, XGL_GPU_COMPATIBILITY_INFO* pInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetMultiGpuCompatibility(VK_PHYSICAL_GPU gpu0, VK_PHYSICAL_GPU gpu1, VK_GPU_COMPATIBILITY_INFO* pInfo)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu0;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu0;
pCurObj = gpuw;
loader_platform_thread_once(&tabOnce, initParamChecker);
- XGL_RESULT result = nextTable.GetMultiGpuCompatibility((XGL_PHYSICAL_GPU)gpuw->nextObject, gpu1, pInfo);
+ VK_RESULT result = nextTable.GetMultiGpuCompatibility((VK_PHYSICAL_GPU)gpuw->nextObject, gpu1, pInfo);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenSharedMemory(XGL_DEVICE device, const XGL_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedMemory(VK_DEVICE device, const VK_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem)
{
char str[1024];
if (!pOpenInfo) {
sprintf(str, "Struct ptr parameter pOpenInfo to function OpenSharedMemory is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_memory_open_info(pOpenInfo)) {
+ else if (!vk_validate_vk_memory_open_info(pOpenInfo)) {
sprintf(str, "Parameter pOpenInfo to function OpenSharedMemory contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem);
+ VK_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenSharedSemaphore(XGL_DEVICE device, const XGL_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_SEMAPHORE* pSemaphore)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedSemaphore(VK_DEVICE device, const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, VK_SEMAPHORE* pSemaphore)
{
char str[1024];
if (!pOpenInfo) {
sprintf(str, "Struct ptr parameter pOpenInfo to function OpenSharedSemaphore is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_semaphore_open_info(pOpenInfo)) {
+ else if (!vk_validate_vk_semaphore_open_info(pOpenInfo)) {
sprintf(str, "Parameter pOpenInfo to function OpenSharedSemaphore contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore);
+ VK_RESULT result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenPeerMemory(XGL_DEVICE device, const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerMemory(VK_DEVICE device, const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem)
{
char str[1024];
if (!pOpenInfo) {
sprintf(str, "Struct ptr parameter pOpenInfo to function OpenPeerMemory is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_peer_memory_open_info(pOpenInfo)) {
+ else if (!vk_validate_vk_peer_memory_open_info(pOpenInfo)) {
sprintf(str, "Parameter pOpenInfo to function OpenPeerMemory contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem);
+ VK_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenPeerImage(XGL_DEVICE device, const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerImage(VK_DEVICE device, const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem)
{
char str[1024];
if (!pOpenInfo) {
sprintf(str, "Struct ptr parameter pOpenInfo to function OpenPeerImage is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_peer_image_open_info(pOpenInfo)) {
+ else if (!vk_validate_vk_peer_image_open_info(pOpenInfo)) {
sprintf(str, "Parameter pOpenInfo to function OpenPeerImage contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem);
+ VK_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyObject(XGL_OBJECT object)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object)
{
- XGL_RESULT result = nextTable.DestroyObject(object);
+ VK_RESULT result = nextTable.DestroyObject(object);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetObjectInfo(XGL_BASE_OBJECT object, XGL_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetObjectInfo(VK_BASE_OBJECT object, VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
{
char str[1024];
- if (!validate_XGL_OBJECT_INFO_TYPE(infoType)) {
+ if (!validate_VK_OBJECT_INFO_TYPE(infoType)) {
sprintf(str, "Parameter infoType to function GetObjectInfo has invalid value of %i.", (int)infoType);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData);
+ VK_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBindObjectMemory(XGL_OBJECT object, uint32_t allocationIdx, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemory(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_MEMORY mem, VK_GPU_SIZE offset)
{
- XGL_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset);
+ VK_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset);
return result;
}
-XGL_LAYER_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)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemoryRange(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_SIZE rangeOffset, VK_GPU_SIZE rangeSize, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset)
{
- XGL_RESULT result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
+ VK_RESULT result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
return result;
}
-XGL_LAYER_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)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBindImageMemoryRange(VK_IMAGE image, uint32_t allocationIdx, const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset)
{
char str[1024];
if (!bindInfo) {
sprintf(str, "Struct ptr parameter bindInfo to function BindImageMemoryRange is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_image_memory_bind_info(bindInfo)) {
+ else if (!vk_validate_vk_image_memory_bind_info(bindInfo)) {
sprintf(str, "Parameter bindInfo to function BindImageMemoryRange contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.BindImageMemoryRange(image, allocationIdx, bindInfo, mem, memOffset);
+ VK_RESULT result = nextTable.BindImageMemoryRange(image, allocationIdx, bindInfo, mem, memOffset);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateFence(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFence(VK_DEVICE device, const VK_FENCE_CREATE_INFO* pCreateInfo, VK_FENCE* pFence)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateFence is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_fence_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_fence_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateFence contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence);
+ VK_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFenceStatus(XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFenceStatus(VK_FENCE fence)
{
- XGL_RESULT result = nextTable.GetFenceStatus(fence);
+ VK_RESULT result = nextTable.GetFenceStatus(fence);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWaitForFences(XGL_DEVICE device, uint32_t fenceCount, const XGL_FENCE* pFences, bool32_t waitAll, uint64_t timeout)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWaitForFences(VK_DEVICE device, uint32_t fenceCount, const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout)
{
- XGL_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
+ VK_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetFences(XGL_DEVICE device, uint32_t fenceCount, XGL_FENCE* pFences)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetFences(VK_DEVICE device, uint32_t fenceCount, VK_FENCE* pFences)
{
- XGL_RESULT result = nextTable.ResetFences(device, fenceCount, pFences);
+ VK_RESULT result = nextTable.ResetFences(device, fenceCount, pFences);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateSemaphore(XGL_DEVICE device, const XGL_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_SEMAPHORE* pSemaphore)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSemaphore(VK_DEVICE device, const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, VK_SEMAPHORE* pSemaphore)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateSemaphore is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_semaphore_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_semaphore_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateSemaphore contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore);
+ VK_RESULT result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSignalSemaphore(XGL_QUEUE queue, XGL_SEMAPHORE semaphore)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSignalSemaphore(VK_QUEUE queue, VK_SEMAPHORE semaphore)
{
- XGL_RESULT result = nextTable.QueueSignalSemaphore(queue, semaphore);
+ VK_RESULT result = nextTable.QueueSignalSemaphore(queue, semaphore);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueWaitSemaphore(XGL_QUEUE queue, XGL_SEMAPHORE semaphore)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitSemaphore(VK_QUEUE queue, VK_SEMAPHORE semaphore)
{
- XGL_RESULT result = nextTable.QueueWaitSemaphore(queue, semaphore);
+ VK_RESULT result = nextTable.QueueWaitSemaphore(queue, semaphore);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateEvent(XGL_DEVICE device, const XGL_EVENT_CREATE_INFO* pCreateInfo, XGL_EVENT* pEvent)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateEvent(VK_DEVICE device, const VK_EVENT_CREATE_INFO* pCreateInfo, VK_EVENT* pEvent)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateEvent is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_event_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_event_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateEvent contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent);
+ VK_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetEventStatus(XGL_EVENT event)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetEventStatus(VK_EVENT event)
{
- XGL_RESULT result = nextTable.GetEventStatus(event);
+ VK_RESULT result = nextTable.GetEventStatus(event);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSetEvent(XGL_EVENT event)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkSetEvent(VK_EVENT event)
{
- XGL_RESULT result = nextTable.SetEvent(event);
+ VK_RESULT result = nextTable.SetEvent(event);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetEvent(XGL_EVENT event)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetEvent(VK_EVENT event)
{
- XGL_RESULT result = nextTable.ResetEvent(event);
+ VK_RESULT result = nextTable.ResetEvent(event);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateQueryPool(XGL_DEVICE device, const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo, XGL_QUERY_POOL* pQueryPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateQueryPool(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateQueryPool is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_query_pool_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_query_pool_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateQueryPool contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool);
+ VK_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetQueryPoolResults(XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetQueryPoolResults(VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData)
{
- XGL_RESULT result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData);
+ VK_RESULT result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFormatInfo(XGL_DEVICE device, XGL_FORMAT format, XGL_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFormatInfo(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData)
{
char str[1024];
- if (!validate_XGL_FORMAT(format)) {
+ if (!validate_VK_FORMAT(format)) {
sprintf(str, "Parameter format to function GetFormatInfo has invalid value of %i.", (int)format);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- if (!validate_XGL_FORMAT_INFO_TYPE(infoType)) {
+ if (!validate_VK_FORMAT_INFO_TYPE(infoType)) {
sprintf(str, "Parameter infoType to function GetFormatInfo has invalid value of %i.", (int)infoType);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData);
+ VK_RESULT result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateBuffer(XGL_DEVICE device, const XGL_BUFFER_CREATE_INFO* pCreateInfo, XGL_BUFFER* pBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateBuffer is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_buffer_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_buffer_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateBuffer contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer);
+ VK_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateBufferView(XGL_DEVICE device, const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo, XGL_BUFFER_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateBufferView is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_buffer_view_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_buffer_view_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateBufferView contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
+ VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
return result;
}
-void PreCreateImage(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo)
+void PreCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo)
{
if(pCreateInfo == nullptr)
{
- char const str[] = "xglCreateImage parameter, XGL_IMAGE_CREATE_INFO* pCreateInfo, is "\
+ char const str[] = "vkCreateImage parameter, VK_IMAGE_CREATE_INFO* pCreateInfo, is "\
"nullptr (precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- if(pCreateInfo->sType != XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO)
+ if(pCreateInfo->sType != VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO)
{
- char const str[] = "xglCreateImage parameter, XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO "\
- "pCreateInfo->sType, is not XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO (precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ char const str[] = "vkCreateImage parameter, VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO "\
+ "pCreateInfo->sType, is not VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO (precondition).";
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- if (!validate_XGL_IMAGE_TYPE(pCreateInfo->imageType))
+ if (!validate_VK_IMAGE_TYPE(pCreateInfo->imageType))
{
- char const str[] = "xglCreateImage parameter, XGL_IMAGE_TYPE pCreateInfo->imageType, is "\
+ char const str[] = "vkCreateImage parameter, VK_IMAGE_TYPE pCreateInfo->imageType, is "\
"unrecognized (precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- if (!validate_XGL_FORMAT(pCreateInfo->format))
+ if (!validate_VK_FORMAT(pCreateInfo->format))
{
- char const str[] = "xglCreateImage parameter, XGL_FORMAT pCreateInfo->format, is "\
+ char const str[] = "vkCreateImage parameter, VK_FORMAT pCreateInfo->format, is "\
"unrecognized (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- XGL_FORMAT_PROPERTIES properties;
+ VK_FORMAT_PROPERTIES properties;
size_t size = sizeof(properties);
- XGL_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->format,
- XGL_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties);
- if(result != XGL_SUCCESS)
+ VK_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->format,
+ VK_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties);
+ if(result != VK_SUCCESS)
{
- char const str[] = "xglCreateImage parameter, XGL_FORMAT pCreateInfo->format, cannot be "\
+ char const str[] = "vkCreateImage parameter, VK_FORMAT pCreateInfo->format, cannot be "\
"validated (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0))
{
- char const str[] = "xglCreateImage parameter, XGL_FORMAT pCreateInfo->format, contains "\
+ char const str[] = "vkCreateImage parameter, VK_FORMAT pCreateInfo->format, contains "\
"unsupported format (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
// TODO: Can we check device-specific limits?
- if (!xgl_validate_xgl_extent3d(&pCreateInfo->extent))
+ if (!vk_validate_vk_extent3d(&pCreateInfo->extent))
{
- char const str[] = "xglCreateImage parameter, XGL_EXTENT3D pCreateInfo->extent, is invalid "\
+ char const str[] = "vkCreateImage parameter, VK_EXTENT3D pCreateInfo->extent, is invalid "\
"(precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- if (!validate_XGL_IMAGE_TILING(pCreateInfo->tiling))
+ if (!validate_VK_IMAGE_TILING(pCreateInfo->tiling))
{
- char const str[] = "xglCreateImage parameter, XGL_IMAGE_TILING pCreateInfo->tiling, is "\
+ char const str[] = "vkCreateImage parameter, VK_IMAGE_TILING pCreateInfo->tiling, is "\
"unrecoginized (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
}
-void PostCreateImage(XGL_RESULT result, XGL_IMAGE* pImage)
+void PostCreateImage(VK_RESULT result, VK_IMAGE* pImage)
{
- if(result != XGL_SUCCESS)
+ if(result != VK_SUCCESS)
{
- // TODO: Spit out XGL_RESULT value.
- char const str[] = "xglCreateImage failed (postcondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ // TODO: Spit out VK_RESULT value.
+ char const str[] = "vkCreateImage failed (postcondition).";
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
if(pImage == nullptr)
{
- char const str[] = "xglCreateImage parameter, XGL_IMAGE* pImage, is nullptr (postcondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ char const str[] = "vkCreateImage parameter, VK_IMAGE* pImage, is nullptr (postcondition).";
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImage(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage)
{
PreCreateImage(device, pCreateInfo);
- XGL_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage);
+ VK_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage);
PostCreateImage(result, pImage);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetImageSubresourceInfo(XGL_IMAGE image, const XGL_IMAGE_SUBRESOURCE* pSubresource, XGL_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkGetImageSubresourceInfo(VK_IMAGE image, const VK_IMAGE_SUBRESOURCE* pSubresource, VK_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData)
{
char str[1024];
if (!pSubresource) {
sprintf(str, "Struct ptr parameter pSubresource to function GetImageSubresourceInfo is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_image_subresource(pSubresource)) {
+ else if (!vk_validate_vk_image_subresource(pSubresource)) {
sprintf(str, "Parameter pSubresource to function GetImageSubresourceInfo contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- if (!validate_XGL_SUBRESOURCE_INFO_TYPE(infoType)) {
+ if (!validate_VK_SUBRESOURCE_INFO_TYPE(infoType)) {
sprintf(str, "Parameter infoType to function GetImageSubresourceInfo has invalid value of %i.", (int)infoType);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData);
+ VK_RESULT result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImageView(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateImageView is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_image_view_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_image_view_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateImageView contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
+ VK_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateColorAttachmentView(XGL_DEVICE device, const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, XGL_COLOR_ATTACHMENT_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, VK_COLOR_ATTACHMENT_VIEW* pView)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateColorAttachmentView is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_color_attachment_view_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_color_attachment_view_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateColorAttachmentView contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView);
+ VK_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDepthStencilView(XGL_DEVICE device, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(VK_DEVICE device, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, VK_DEPTH_STENCIL_VIEW* pView)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateDepthStencilView is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_depth_stencil_view_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_depth_stencil_view_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateDepthStencilView contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView);
+ VK_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateShader(XGL_DEVICE device, const XGL_SHADER_CREATE_INFO* pCreateInfo, XGL_SHADER* pShader)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateShader(VK_DEVICE device, const VK_SHADER_CREATE_INFO* pCreateInfo, VK_SHADER* pShader)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateShader is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_shader_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_shader_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateShader contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader);
+ VK_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateGraphicsPipeline is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_graphics_pipeline_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_graphics_pipeline_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateGraphicsPipeline contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+ VK_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE basePipeline, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE basePipeline, VK_PIPELINE* pPipeline)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateGraphicsPipelineDerivative is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_graphics_pipeline_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_graphics_pipeline_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateGraphicsPipelineDerivative contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
+ VK_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(VK_DEVICE device, const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateComputePipeline is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_compute_pipeline_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_compute_pipeline_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateComputePipeline contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
+ VK_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglStorePipeline(XGL_PIPELINE pipeline, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkStorePipeline(VK_PIPELINE pipeline, size_t* pDataSize, void* pData)
{
- XGL_RESULT result = nextTable.StorePipeline(pipeline, pDataSize, pData);
+ VK_RESULT result = nextTable.StorePipeline(pipeline, pDataSize, pData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglLoadPipeline(XGL_DEVICE device, size_t dataSize, const void* pData, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkLoadPipeline(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE* pPipeline)
{
- XGL_RESULT result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline);
+ VK_RESULT result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglLoadPipelineDerivative(XGL_DEVICE device, size_t dataSize, const void* pData, XGL_PIPELINE basePipeline, XGL_PIPELINE* pPipeline)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkLoadPipelineDerivative(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE basePipeline, VK_PIPELINE* pPipeline)
{
- XGL_RESULT result = nextTable.LoadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline);
+ VK_RESULT result = nextTable.LoadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateSampler(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateSampler is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_sampler_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_sampler_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateSampler contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
+ VK_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSetLayout(XGL_DEVICE device, const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout(VK_DEVICE device, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_SET_LAYOUT* pSetLayout)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateDescriptorSetLayout is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_descriptor_set_layout_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_descriptor_set_layout_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateDescriptorSetLayout contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+ VK_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSetLayoutChain(XGL_DEVICE device, uint32_t setLayoutArrayCount, const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, XGL_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain(VK_DEVICE device, uint32_t setLayoutArrayCount, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain)
{
- XGL_RESULT result = nextTable.CreateDescriptorSetLayoutChain(device, setLayoutArrayCount, pSetLayoutArray, pLayoutChain);
+ VK_RESULT result = nextTable.CreateDescriptorSetLayoutChain(device, setLayoutArrayCount, pSetLayoutArray, pLayoutChain);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginDescriptorPoolUpdate(XGL_DEVICE device, XGL_DESCRIPTOR_UPDATE_MODE updateMode)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(VK_DEVICE device, VK_DESCRIPTOR_UPDATE_MODE updateMode)
{
char str[1024];
- if (!validate_XGL_DESCRIPTOR_UPDATE_MODE(updateMode)) {
+ if (!validate_VK_DESCRIPTOR_UPDATE_MODE(updateMode)) {
sprintf(str, "Parameter updateMode to function BeginDescriptorPoolUpdate has invalid value of %i.", (int)updateMode);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode);
+ VK_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEndDescriptorPoolUpdate(XGL_DEVICE device, XGL_CMD_BUFFER cmd)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEndDescriptorPoolUpdate(VK_DEVICE device, VK_CMD_BUFFER cmd)
{
- XGL_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd);
+ VK_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorPool(XGL_DEVICE device, XGL_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const XGL_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_POOL* pDescriptorPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_POOL* pDescriptorPool)
{
char str[1024];
- if (!validate_XGL_DESCRIPTOR_POOL_USAGE(poolUsage)) {
+ if (!validate_VK_DESCRIPTOR_POOL_USAGE(poolUsage)) {
sprintf(str, "Parameter poolUsage to function CreateDescriptorPool has invalid value of %i.", (int)poolUsage);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateDescriptorPool is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_descriptor_pool_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_descriptor_pool_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateDescriptorPool contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
+ VK_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetDescriptorPool(XGL_DESCRIPTOR_POOL descriptorPool)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetDescriptorPool(VK_DESCRIPTOR_POOL descriptorPool)
{
- XGL_RESULT result = nextTable.ResetDescriptorPool(descriptorPool);
+ VK_RESULT result = nextTable.ResetDescriptorPool(descriptorPool);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglAllocDescriptorSets(XGL_DESCRIPTOR_POOL descriptorPool, XGL_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts, XGL_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount)
{
char str[1024];
- if (!validate_XGL_DESCRIPTOR_SET_USAGE(setUsage)) {
+ if (!validate_VK_DESCRIPTOR_SET_USAGE(setUsage)) {
sprintf(str, "Parameter setUsage to function AllocDescriptorSets has invalid value of %i.", (int)setUsage);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
+ VK_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
return result;
}
-XGL_LAYER_EXPORT void XGLAPI xglClearDescriptorSets(XGL_DESCRIPTOR_POOL descriptorPool, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets)
+VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets)
{
nextTable.ClearDescriptorSets(descriptorPool, count, pDescriptorSets);
}
-XGL_LAYER_EXPORT void XGLAPI xglUpdateDescriptors(XGL_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray)
+VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray)
{
nextTable.UpdateDescriptors(descriptorSet, updateCount, ppUpdateArray);
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicViewportState(XGL_DEVICE device, const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_VP_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_VP_STATE_OBJECT* pState)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateDynamicViewportState is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_dynamic_vp_state_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_dynamic_vp_state_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateDynamicViewportState contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
+ VK_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicRasterState(XGL_DEVICE device, const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_RS_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_RS_STATE_OBJECT* pState)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateDynamicRasterState is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_dynamic_rs_state_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_dynamic_rs_state_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateDynamicRasterState contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
+ VK_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicColorBlendState(XGL_DEVICE device, const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_CB_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_CB_STATE_OBJECT* pState)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateDynamicColorBlendState is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_dynamic_cb_state_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_dynamic_cb_state_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateDynamicColorBlendState contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
+ VK_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState(XGL_DEVICE device, const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_DS_STATE_OBJECT* pState)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_DS_STATE_OBJECT* pState)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateDynamicDepthStencilState is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_dynamic_ds_state_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_dynamic_ds_state_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateDynamicDepthStencilState contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
+ VK_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
return result;
}
-void PreCreateCommandBuffer(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo)
+void PreCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo)
{
if(device == nullptr)
{
- char const str[] = "xglCreateCommandBuffer parameter, XGL_DEVICE device, is "\
+ char const str[] = "vkCreateCommandBuffer parameter, VK_DEVICE device, is "\
"nullptr (precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
if(pCreateInfo == nullptr)
{
- char const str[] = "xglCreateCommandBuffer parameter, XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, is "\
+ char const str[] = "vkCreateCommandBuffer parameter, VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, is "\
"nullptr (precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- if(pCreateInfo->sType != XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO)
+ if(pCreateInfo->sType != VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO)
{
- char const str[] = "xglCreateCommandBuffer parameter, XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO "\
- "pCreateInfo->sType, is not XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO (precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ char const str[] = "vkCreateCommandBuffer parameter, VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO "\
+ "pCreateInfo->sType, is not VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO (precondition).";
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
}
-void PostCreateCommandBuffer(XGL_RESULT result, XGL_CMD_BUFFER* pCmdBuffer)
+void PostCreateCommandBuffer(VK_RESULT result, VK_CMD_BUFFER* pCmdBuffer)
{
- if(result != XGL_SUCCESS)
+ if(result != VK_SUCCESS)
{
- // TODO: Spit out XGL_RESULT value.
- char const str[] = "xglCreateCommandBuffer failed (postcondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ // TODO: Spit out VK_RESULT value.
+ char const str[] = "vkCreateCommandBuffer failed (postcondition).";
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
if(pCmdBuffer == nullptr)
{
- char const str[] = "xglCreateCommandBuffer parameter, XGL_CMD_BUFFER* pCmdBuffer, is nullptr (postcondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ char const str[] = "vkCreateCommandBuffer parameter, VK_CMD_BUFFER* pCmdBuffer, is nullptr (postcondition).";
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateCommandBuffer(XGL_DEVICE device,
- const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device,
+ const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer)
{
PreCreateCommandBuffer(device, pCreateInfo);
- XGL_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+ VK_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
PostCreateCommandBuffer(result, pCmdBuffer);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginCommandBuffer(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
{
char str[1024];
if (!pBeginInfo) {
sprintf(str, "Struct ptr parameter pBeginInfo to function BeginCommandBuffer is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_cmd_buffer_begin_info(pBeginInfo)) {
+ else if (!vk_validate_vk_cmd_buffer_begin_info(pBeginInfo)) {
sprintf(str, "Parameter pBeginInfo to function BeginCommandBuffer contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
+ VK_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEndCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer)
{
- XGL_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
+ VK_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer)
{
- XGL_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
+ VK_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
return result;
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindPipeline(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline)
+VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline)
{
char str[1024];
- if (!validate_XGL_PIPELINE_BIND_POINT(pipelineBindPoint)) {
+ if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) {
sprintf(str, "Parameter pipelineBindPoint to function CmdBindPipeline has invalid value of %i.", (int)pipelineBindPoint);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDynamicStateObject(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state)
{
char str[1024];
- if (!validate_XGL_STATE_BIND_POINT(stateBindPoint)) {
+ if (!validate_VK_STATE_BIND_POINT(stateBindPoint)) {
sprintf(str, "Parameter stateBindPoint to function CmdBindDynamicStateObject has invalid value of %i.", (int)stateBindPoint);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
nextTable.CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDescriptorSets(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const XGL_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData)
{
char str[1024];
- if (!validate_XGL_PIPELINE_BIND_POINT(pipelineBindPoint)) {
+ if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) {
sprintf(str, "Parameter pipelineBindPoint to function CmdBindDescriptorSets has invalid value of %i.", (int)pipelineBindPoint);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindVertexBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t binding)
+VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding)
{
nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindIndexBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType)
+VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType)
{
char str[1024];
- if (!validate_XGL_INDEX_TYPE(indexType)) {
+ if (!validate_VK_INDEX_TYPE(indexType)) {
sprintf(str, "Parameter indexType to function CmdBindIndexBuffer has invalid value of %i.", (int)indexType);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDraw(XGL_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
+VK_LAYER_EXPORT void VKAPI vkCmdDraw(VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
{
nextTable.CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndexed(XGL_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
{
nextTable.CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride)
{
nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDrawIndexedIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride)
{
nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDispatch(XGL_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
{
nextTable.CmdDispatch(cmdBuffer, x, y, z);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDispatchIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset)
{
nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_COPY* pRegions)
{
char str[1024];
uint32_t i;
for (i = 0; i < regionCount; i++) {
- if (!xgl_validate_xgl_buffer_copy(&pRegions[i])) {
+ if (!vk_validate_vk_buffer_copy(&pRegions[i])) {
sprintf(str, "Parameter pRegions[%i] to function CmdCopyBuffer contains an invalid value.", i);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
}
nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_COPY* pRegions)
{
char str[1024];
- if (!validate_XGL_IMAGE_LAYOUT(srcImageLayout)) {
+ if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) {
sprintf(str, "Parameter srcImageLayout to function CmdCopyImage has invalid value of %i.", (int)srcImageLayout);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- if (!validate_XGL_IMAGE_LAYOUT(destImageLayout)) {
+ if (!validate_VK_IMAGE_LAYOUT(destImageLayout)) {
sprintf(str, "Parameter destImageLayout to function CmdCopyImage has invalid value of %i.", (int)destImageLayout);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
uint32_t i;
for (i = 0; i < regionCount; i++) {
- if (!xgl_validate_xgl_image_copy(&pRegions[i])) {
+ if (!vk_validate_vk_image_copy(&pRegions[i])) {
sprintf(str, "Parameter pRegions[%i] to function CmdCopyImage contains an invalid value.", i);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
}
nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBlitImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_IMAGE_BLIT* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_BLIT* pRegions)
{
char str[1024];
- if (!validate_XGL_IMAGE_LAYOUT(srcImageLayout)) {
+ if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) {
sprintf(str, "Parameter srcImageLayout to function CmdBlitImage has invalid value of %i.", (int)srcImageLayout);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- if (!validate_XGL_IMAGE_LAYOUT(destImageLayout)) {
+ if (!validate_VK_IMAGE_LAYOUT(destImageLayout)) {
sprintf(str, "Parameter destImageLayout to function CmdBlitImage has invalid value of %i.", (int)destImageLayout);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
uint32_t i;
for (i = 0; i < regionCount; i++) {
- if (!xgl_validate_xgl_image_blit(&pRegions[i])) {
+ if (!vk_validate_vk_image_blit(&pRegions[i])) {
sprintf(str, "Parameter pRegions[%i] to function CmdBlitImage contains an invalid value.", i);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
}
nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBufferToImage(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions)
{
char str[1024];
- if (!validate_XGL_IMAGE_LAYOUT(destImageLayout)) {
+ if (!validate_VK_IMAGE_LAYOUT(destImageLayout)) {
sprintf(str, "Parameter destImageLayout to function CmdCopyBufferToImage has invalid value of %i.", (int)destImageLayout);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
uint32_t i;
for (i = 0; i < regionCount; i++) {
- if (!xgl_validate_xgl_buffer_image_copy(&pRegions[i])) {
+ if (!vk_validate_vk_buffer_image_copy(&pRegions[i])) {
sprintf(str, "Parameter pRegions[%i] to function CmdCopyBufferToImage contains an invalid value.", i);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
}
nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImageToBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions)
{
char str[1024];
- if (!validate_XGL_IMAGE_LAYOUT(srcImageLayout)) {
+ if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) {
sprintf(str, "Parameter srcImageLayout to function CmdCopyImageToBuffer has invalid value of %i.", (int)srcImageLayout);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
uint32_t i;
for (i = 0; i < regionCount; i++) {
- if (!xgl_validate_xgl_buffer_image_copy(&pRegions[i])) {
+ if (!vk_validate_vk_buffer_image_copy(&pRegions[i])) {
sprintf(str, "Parameter pRegions[%i] to function CmdCopyImageToBuffer contains an invalid value.", i);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
}
nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdCloneImageData(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout)
+VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout)
{
char str[1024];
- if (!validate_XGL_IMAGE_LAYOUT(srcImageLayout)) {
+ if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) {
sprintf(str, "Parameter srcImageLayout to function CmdCloneImageData has invalid value of %i.", (int)srcImageLayout);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- if (!validate_XGL_IMAGE_LAYOUT(destImageLayout)) {
+ if (!validate_VK_IMAGE_LAYOUT(destImageLayout)) {
sprintf(str, "Parameter destImageLayout to function CmdCloneImageData has invalid value of %i.", (int)destImageLayout);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdUpdateBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData)
{
nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdFillBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, uint32_t data)
+VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data)
{
nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearColorImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout, XGL_CLEAR_COLOR color, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, VK_CLEAR_COLOR color, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
{
char str[1024];
- if (!validate_XGL_IMAGE_LAYOUT(imageLayout)) {
+ if (!validate_VK_IMAGE_LAYOUT(imageLayout)) {
sprintf(str, "Parameter imageLayout to function CmdClearColorImage has invalid value of %i.", (int)imageLayout);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
uint32_t i;
for (i = 0; i < rangeCount; i++) {
- if (!xgl_validate_xgl_image_subresource_range(&pRanges[i])) {
+ if (!vk_validate_vk_image_subresource_range(&pRanges[i])) {
sprintf(str, "Parameter pRanges[%i] to function CmdClearColorImage contains an invalid value.", i);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
}
nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearDepthStencil(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
{
char str[1024];
- if (!validate_XGL_IMAGE_LAYOUT(imageLayout)) {
+ if (!validate_VK_IMAGE_LAYOUT(imageLayout)) {
sprintf(str, "Parameter imageLayout to function CmdClearDepthStencil has invalid value of %i.", (int)imageLayout);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
uint32_t i;
for (i = 0; i < rangeCount; i++) {
- if (!xgl_validate_xgl_image_subresource_range(&pRanges[i])) {
+ if (!vk_validate_vk_image_subresource_range(&pRanges[i])) {
sprintf(str, "Parameter pRanges[%i] to function CmdClearDepthStencil contains an invalid value.", i);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
}
nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdResolveImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects)
+VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects)
{
char str[1024];
- if (!validate_XGL_IMAGE_LAYOUT(srcImageLayout)) {
+ if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) {
sprintf(str, "Parameter srcImageLayout to function CmdResolveImage has invalid value of %i.", (int)srcImageLayout);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- if (!validate_XGL_IMAGE_LAYOUT(destImageLayout)) {
+ if (!validate_VK_IMAGE_LAYOUT(destImageLayout)) {
sprintf(str, "Parameter destImageLayout to function CmdResolveImage has invalid value of %i.", (int)destImageLayout);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
uint32_t i;
for (i = 0; i < rectCount; i++) {
- if (!xgl_validate_xgl_image_resolve(&pRects[i])) {
+ if (!vk_validate_vk_image_resolve(&pRects[i])) {
sprintf(str, "Parameter pRects[%i] to function CmdResolveImage contains an invalid value.", i);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
}
nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdSetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent)
+VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent)
{
char str[1024];
- if (!validate_XGL_PIPE_EVENT(pipeEvent)) {
+ if (!validate_VK_PIPE_EVENT(pipeEvent)) {
sprintf(str, "Parameter pipeEvent to function CmdSetEvent has invalid value of %i.", (int)pipeEvent);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
nextTable.CmdSetEvent(cmdBuffer, event, pipeEvent);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdResetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent)
+VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent)
{
char str[1024];
- if (!validate_XGL_PIPE_EVENT(pipeEvent)) {
+ if (!validate_VK_PIPE_EVENT(pipeEvent)) {
sprintf(str, "Parameter pipeEvent to function CmdResetEvent has invalid value of %i.", (int)pipeEvent);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
nextTable.CmdResetEvent(cmdBuffer, event, pipeEvent);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdWaitEvents(XGL_CMD_BUFFER cmdBuffer, const XGL_EVENT_WAIT_INFO* pWaitInfo)
+VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVENT_WAIT_INFO* pWaitInfo)
{
char str[1024];
if (!pWaitInfo) {
sprintf(str, "Struct ptr parameter pWaitInfo to function CmdWaitEvents is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_event_wait_info(pWaitInfo)) {
+ else if (!vk_validate_vk_event_wait_info(pWaitInfo)) {
sprintf(str, "Parameter pWaitInfo to function CmdWaitEvents contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
nextTable.CmdWaitEvents(cmdBuffer, pWaitInfo);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdPipelineBarrier(XGL_CMD_BUFFER cmdBuffer, const XGL_PIPELINE_BARRIER* pBarrier)
+VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const VK_PIPELINE_BARRIER* pBarrier)
{
char str[1024];
if (!pBarrier) {
sprintf(str, "Struct ptr parameter pBarrier to function CmdPipelineBarrier is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_pipeline_barrier(pBarrier)) {
+ else if (!vk_validate_vk_pipeline_barrier(pBarrier)) {
sprintf(str, "Parameter pBarrier to function CmdPipelineBarrier contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
nextTable.CmdPipelineBarrier(cmdBuffer, pBarrier);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot, XGL_FLAGS flags)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags)
{
nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdEndQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot)
+VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot)
{
nextTable.CmdEndQuery(cmdBuffer, queryPool, slot);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdResetQueryPool(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount)
+VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount)
{
nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdWriteTimestamp(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset)
+VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMESTAMP_TYPE timestampType, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset)
{
char str[1024];
- if (!validate_XGL_TIMESTAMP_TYPE(timestampType)) {
+ if (!validate_VK_TIMESTAMP_TYPE(timestampType)) {
sprintf(str, "Parameter timestampType to function CmdWriteTimestamp has invalid value of %i.", (int)timestampType);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
nextTable.CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdInitAtomicCounters(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData)
{
char str[1024];
- if (!validate_XGL_PIPELINE_BIND_POINT(pipelineBindPoint)) {
+ if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) {
sprintf(str, "Parameter pipelineBindPoint to function CmdInitAtomicCounters has invalid value of %i.", (int)pipelineBindPoint);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
nextTable.CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData);
}
-XGL_LAYER_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)
+VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER srcBuffer, VK_GPU_SIZE srcOffset)
{
char str[1024];
- if (!validate_XGL_PIPELINE_BIND_POINT(pipelineBindPoint)) {
+ if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) {
sprintf(str, "Parameter pipelineBindPoint to function CmdLoadAtomicCounters has invalid value of %i.", (int)pipelineBindPoint);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
nextTable.CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset);
}
-XGL_LAYER_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)
+VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset)
{
char str[1024];
- if (!validate_XGL_PIPELINE_BIND_POINT(pipelineBindPoint)) {
+ if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) {
sprintf(str, "Parameter pipelineBindPoint to function CmdSaveAtomicCounters has invalid value of %i.", (int)pipelineBindPoint);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
nextTable.CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset);
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateFramebuffer(XGL_DEVICE device, const XGL_FRAMEBUFFER_CREATE_INFO* pCreateInfo, XGL_FRAMEBUFFER* pFramebuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(VK_DEVICE device, const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, VK_FRAMEBUFFER* pFramebuffer)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateFramebuffer is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_framebuffer_create_info(pCreateInfo)) {
+ else if (!vk_validate_vk_framebuffer_create_info(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateFramebuffer contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+ VK_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer);
return result;
}
-void PreCreateRenderPass(XGL_DEVICE device, const XGL_RENDER_PASS_CREATE_INFO* pCreateInfo)
+void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo)
{
if(pCreateInfo == nullptr)
{
- char const str[] = "xglCreateRenderPass parameter, XGL_RENDER_PASS_CREATE_INFO* pCreateInfo, is "\
+ char const str[] = "vkCreateRenderPass parameter, VK_RENDER_PASS_CREATE_INFO* pCreateInfo, is "\
"nullptr (precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- if(pCreateInfo->sType != XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO)
+ if(pCreateInfo->sType != VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO)
{
- char const str[] = "xglCreateRenderPass parameter, XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO "\
- "pCreateInfo->sType, is not XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO (precondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ char const str[] = "vkCreateRenderPass parameter, VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO "\
+ "pCreateInfo->sType, is not VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO (precondition).";
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- if(!xgl_validate_xgl_rect(&pCreateInfo->renderArea))
+ if(!vk_validate_vk_rect(&pCreateInfo->renderArea))
{
- char const str[] = "xglCreateRenderPass parameter, XGL_RECT pCreateInfo->renderArea, is invalid "\
+ char const str[] = "vkCreateRenderPass parameter, VK_RECT pCreateInfo->renderArea, is invalid "\
"(precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- if(!xgl_validate_xgl_extent2d(&pCreateInfo->extent))
+ if(!vk_validate_vk_extent2d(&pCreateInfo->extent))
{
- char const str[] = "xglCreateRenderPass parameter, XGL_EXTENT2D pCreateInfo->extent, is invalid "\
+ char const str[] = "vkCreateRenderPass parameter, VK_EXTENT2D pCreateInfo->extent, is invalid "\
"(precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
if(pCreateInfo->pColorFormats == nullptr)
{
- char const str[] = "xglCreateRenderPass parameter, XGL_FORMAT* pCreateInfo->pColorFormats, "\
+ char const str[] = "vkCreateRenderPass parameter, VK_FORMAT* pCreateInfo->pColorFormats, "\
"is nullptr (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
{
- if(!validate_XGL_FORMAT(pCreateInfo->pColorFormats[i]))
+ if(!validate_VK_FORMAT(pCreateInfo->pColorFormats[i]))
{
std::stringstream ss;
- ss << "xglCreateRenderPass parameter, XGL_FORMAT pCreateInfo->pColorFormats[" << i <<
+ ss << "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->pColorFormats[" << i <<
"], is unrecognized (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
continue;
}
- XGL_FORMAT_PROPERTIES properties;
+ VK_FORMAT_PROPERTIES properties;
size_t size = sizeof(properties);
- XGL_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->pColorFormats[i],
- XGL_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties);
- if(result != XGL_SUCCESS)
+ VK_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->pColorFormats[i],
+ VK_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties);
+ if(result != VK_SUCCESS)
{
std::stringstream ss;
- ss << "xglCreateRenderPass parameter, XGL_FORMAT pCreateInfo->pColorFormats[" << i <<
+ ss << "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->pColorFormats[" << i <<
"], cannot be validated (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
continue;
}
if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0))
{
std::stringstream ss;
- ss << "xglCreateRenderPass parameter, XGL_FORMAT pCreateInfo->pColorFormats[" << i <<
+ ss << "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->pColorFormats[" << i <<
"], contains unsupported format (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
continue;
}
@@ -1612,260 +1613,260 @@
if(pCreateInfo->pColorLayouts == nullptr)
{
- char const str[] = "xglCreateRenderPass parameter, XGL_IMAGE_LAYOUT* pCreateInfo->pColorLayouts, "\
+ char const str[] = "vkCreateRenderPass parameter, VK_IMAGE_LAYOUT* pCreateInfo->pColorLayouts, "\
"is nullptr (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
{
- if(!validate_XGL_IMAGE_LAYOUT(pCreateInfo->pColorLayouts[i]))
+ if(!validate_VK_IMAGE_LAYOUT(pCreateInfo->pColorLayouts[i]))
{
std::stringstream ss;
- ss << "xglCreateRenderPass parameter, XGL_IMAGE_LAYOUT pCreateInfo->pColorLayouts[" << i <<
+ ss << "vkCreateRenderPass parameter, VK_IMAGE_LAYOUT pCreateInfo->pColorLayouts[" << i <<
"], is unrecognized (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
continue;
}
}
if(pCreateInfo->pColorLoadOps == nullptr)
{
- char const str[] = "xglCreateRenderPass parameter, XGL_ATTACHMENT_LOAD_OP* pCreateInfo->pColorLoadOps, "\
+ char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_LOAD_OP* pCreateInfo->pColorLoadOps, "\
"is nullptr (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
{
- if(!validate_XGL_ATTACHMENT_LOAD_OP(pCreateInfo->pColorLoadOps[i]))
+ if(!validate_VK_ATTACHMENT_LOAD_OP(pCreateInfo->pColorLoadOps[i]))
{
std::stringstream ss;
- ss << "xglCreateRenderPass parameter, XGL_ATTACHMENT_LOAD_OP pCreateInfo->pColorLoadOps[" << i <<
+ ss << "vkCreateRenderPass parameter, VK_ATTACHMENT_LOAD_OP pCreateInfo->pColorLoadOps[" << i <<
"], is unrecognized (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
continue;
}
}
if(pCreateInfo->pColorStoreOps == nullptr)
{
- char const str[] = "xglCreateRenderPass parameter, XGL_ATTACHMENT_STORE_OP* pCreateInfo->pColorStoreOps, "\
+ char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP* pCreateInfo->pColorStoreOps, "\
"is nullptr (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
{
- if(!validate_XGL_ATTACHMENT_STORE_OP(pCreateInfo->pColorStoreOps[i]))
+ if(!validate_VK_ATTACHMENT_STORE_OP(pCreateInfo->pColorStoreOps[i]))
{
std::stringstream ss;
- ss << "xglCreateRenderPass parameter, XGL_ATTACHMENT_STORE_OP pCreateInfo->pColorStoreOps[" << i <<
+ ss << "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP pCreateInfo->pColorStoreOps[" << i <<
"], is unrecognized (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
continue;
}
}
if(pCreateInfo->pColorLoadClearValues == nullptr)
{
- char const str[] = "xglCreateRenderPass parameter, XGL_CLEAR_COLOR* pCreateInfo->"\
+ char const str[] = "vkCreateRenderPass parameter, VK_CLEAR_COLOR* pCreateInfo->"\
"pColorLoadClearValues, is nullptr (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
if(pCreateInfo->pColorStoreOps == nullptr)
{
- char const str[] = "xglCreateRenderPass parameter, XGL_ATTACHMENT_STORE_OP* pCreateInfo->pColorStoreOps, "\
+ char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP* pCreateInfo->pColorStoreOps, "\
"is nullptr (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
{
- if(!validate_XGL_ATTACHMENT_STORE_OP(pCreateInfo->pColorStoreOps[i]))
+ if(!validate_VK_ATTACHMENT_STORE_OP(pCreateInfo->pColorStoreOps[i]))
{
std::stringstream ss;
- ss << "xglCreateRenderPass parameter, XGL_ATTACHMENT_STORE_OP pCreateInfo->pColorStoreOps[" << i <<
+ ss << "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP pCreateInfo->pColorStoreOps[" << i <<
"], is unrecognized (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
continue;
}
}
if(pCreateInfo->pColorLoadClearValues == nullptr)
{
- char const str[] = "xglCreateRenderPass parameter, XGL_CLEAR_COLOR* pCreateInfo->"\
+ char const str[] = "vkCreateRenderPass parameter, VK_CLEAR_COLOR* pCreateInfo->"\
"pColorLoadClearValues, is nullptr (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
{
- if(!xgl_validate_xgl_clear_color(&(pCreateInfo->pColorLoadClearValues[i])))
+ if(!vk_validate_vk_clear_color(&(pCreateInfo->pColorLoadClearValues[i])))
{
std::stringstream ss;
- ss << "xglCreateRenderPass parameter, XGL_CLEAR_COLOR pCreateInfo->pColorLoadClearValues[" << i <<
+ ss << "vkCreateRenderPass parameter, VK_CLEAR_COLOR pCreateInfo->pColorLoadClearValues[" << i <<
"], is invalid (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
continue;
}
}
- if(!validate_XGL_FORMAT(pCreateInfo->depthStencilFormat))
+ if(!validate_VK_FORMAT(pCreateInfo->depthStencilFormat))
{
- char const str[] = "xglCreateRenderPass parameter, XGL_FORMAT pCreateInfo->"\
+ char const str[] = "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->"\
"depthStencilFormat, is unrecognized (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- XGL_FORMAT_PROPERTIES properties;
+ VK_FORMAT_PROPERTIES properties;
size_t size = sizeof(properties);
- XGL_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->depthStencilFormat,
- XGL_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties);
- if(result != XGL_SUCCESS)
+ VK_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->depthStencilFormat,
+ VK_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties);
+ if(result != VK_SUCCESS)
{
- char const str[] = "xglCreateRenderPass parameter, XGL_FORMAT pCreateInfo->"\
+ char const str[] = "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->"\
"depthStencilFormat, cannot be validated (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0))
{
- char const str[] = "xglCreateRenderPass parameter, XGL_FORMAT pCreateInfo->"\
+ char const str[] = "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->"\
"depthStencilFormat, contains unsupported format (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- if(!validate_XGL_IMAGE_LAYOUT(pCreateInfo->depthStencilLayout))
+ if(!validate_VK_IMAGE_LAYOUT(pCreateInfo->depthStencilLayout))
{
- char const str[] = "xglCreateRenderPass parameter, XGL_IMAGE_LAYOUT pCreateInfo->"\
+ char const str[] = "vkCreateRenderPass parameter, VK_IMAGE_LAYOUT pCreateInfo->"\
"depthStencilLayout, is unrecognized (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- if(!validate_XGL_ATTACHMENT_LOAD_OP(pCreateInfo->depthLoadOp))
+ if(!validate_VK_ATTACHMENT_LOAD_OP(pCreateInfo->depthLoadOp))
{
- char const str[] = "xglCreateRenderPass parameter, XGL_ATTACHMENT_LOAD_OP pCreateInfo->"\
+ char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_LOAD_OP pCreateInfo->"\
"depthLoadOp, is unrecognized (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- if(!validate_XGL_ATTACHMENT_STORE_OP(pCreateInfo->depthStoreOp))
+ if(!validate_VK_ATTACHMENT_STORE_OP(pCreateInfo->depthStoreOp))
{
- char const str[] = "xglCreateRenderPass parameter, XGL_ATTACHMENT_STORE_OP pCreateInfo->"\
+ char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP pCreateInfo->"\
"depthStoreOp, is unrecognized (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- if(!validate_XGL_ATTACHMENT_LOAD_OP(pCreateInfo->stencilLoadOp))
+ if(!validate_VK_ATTACHMENT_LOAD_OP(pCreateInfo->stencilLoadOp))
{
- char const str[] = "xglCreateRenderPass parameter, XGL_ATTACHMENT_LOAD_OP pCreateInfo->"\
+ char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_LOAD_OP pCreateInfo->"\
"stencilLoadOp, is unrecognized (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
- if(!validate_XGL_ATTACHMENT_STORE_OP(pCreateInfo->stencilStoreOp))
+ if(!validate_VK_ATTACHMENT_STORE_OP(pCreateInfo->stencilStoreOp))
{
- char const str[] = "xglCreateRenderPass parameter, XGL_ATTACHMENT_STORE_OP pCreateInfo->"\
+ char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP pCreateInfo->"\
"stencilStoreOp, is unrecognized (precondition).";
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
}
-void PostCreateRenderPass(XGL_RESULT result, XGL_RENDER_PASS* pRenderPass)
+void PostCreateRenderPass(VK_RESULT result, VK_RENDER_PASS* pRenderPass)
{
- if(result != XGL_SUCCESS)
+ if(result != VK_SUCCESS)
{
- // TODO: Spit out XGL_RESULT value.
- char const str[] = "xglCreateRenderPass failed (postcondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ // TODO: Spit out VK_RESULT value.
+ char const str[] = "vkCreateRenderPass failed (postcondition).";
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
if(pRenderPass == nullptr)
{
- char const str[] = "xglCreateRenderPass parameter, XGL_RENDER_PASS* pRenderPass, is nullptr (postcondition).";
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ char const str[] = "vkCreateRenderPass parameter, VK_RENDER_PASS* pRenderPass, is nullptr (postcondition).";
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
}
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateRenderPass(XGL_DEVICE device, const XGL_RENDER_PASS_CREATE_INFO* pCreateInfo, XGL_RENDER_PASS* pRenderPass)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, VK_RENDER_PASS* pRenderPass)
{
PreCreateRenderPass(device, pCreateInfo);
- XGL_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass);
+ VK_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass);
PostCreateRenderPass(result, pRenderPass);
return result;
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginRenderPass(XGL_CMD_BUFFER cmdBuffer, const XGL_RENDER_PASS_BEGIN* pRenderPassBegin)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const VK_RENDER_PASS_BEGIN* pRenderPassBegin)
{
char str[1024];
if (!pRenderPassBegin) {
sprintf(str, "Struct ptr parameter pRenderPassBegin to function CmdBeginRenderPass is NULL.");
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!xgl_validate_xgl_render_pass_begin(pRenderPassBegin)) {
+ else if (!vk_validate_vk_render_pass_begin(pRenderPassBegin)) {
sprintf(str, "Parameter pRenderPassBegin to function CmdBeginRenderPass contains an invalid value.");
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
nextTable.CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdEndRenderPass(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass)
+VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VK_CMD_BUFFER cmdBuffer, VK_RENDER_PASS renderPass)
{
nextTable.CmdEndRenderPass(cmdBuffer, renderPass);
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetValidationLevel(XGL_DEVICE device, XGL_VALIDATION_LEVEL validationLevel)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetValidationLevel(VK_DEVICE device, VK_VALIDATION_LEVEL validationLevel)
{
char str[1024];
- if (!validate_XGL_VALIDATION_LEVEL(validationLevel)) {
+ if (!validate_VK_VALIDATION_LEVEL(validationLevel)) {
sprintf(str, "Parameter validationLevel to function DbgSetValidationLevel has invalid value of %i.", (int)validationLevel);
- layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- XGL_RESULT result = nextTable.DbgSetValidationLevel(device, validationLevel);
+ VK_RESULT result = nextTable.DbgSetValidationLevel(device, validationLevel);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
{
// This layer intercepts callbacks
- XGL_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (XGL_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(XGL_LAYER_DBG_FUNCTION_NODE));
+ VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE));
if (!pNewDbgFuncNode)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;
pNewDbgFuncNode->pUserData = pUserData;
pNewDbgFuncNode->pNext = g_pDbgFunctionHead;
g_pDbgFunctionHead = pNewDbgFuncNode;
// force callbacks if DebugAction hasn't been set already other than initial value
if (g_actionIsDefault) {
- g_debugAction = XGL_DBG_LAYER_ACTION_CALLBACK;
+ g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK;
}
- XGL_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
+ VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
{
- XGL_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
- XGL_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;
+ VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
+ VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;
while (pTrav) {
if (pTrav->pfnMsgCallback == pfnMsgCallback) {
pPrev->pNext = pTrav->pNext;
@@ -1880,49 +1881,49 @@
if (g_pDbgFunctionHead == NULL)
{
if (g_actionIsDefault)
- g_debugAction = XGL_DBG_LAYER_ACTION_LOG_MSG;
+ g_debugAction = VK_DBG_LAYER_ACTION_LOG_MSG;
else
- g_debugAction = (XGL_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)XGL_DBG_LAYER_ACTION_CALLBACK));
+ g_debugAction = (VK_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)VK_DBG_LAYER_ACTION_CALLBACK));
}
- XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
+ VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetMessageFilter(XGL_DEVICE device, int32_t msgCode, XGL_DBG_MSG_FILTER filter)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetMessageFilter(VK_DEVICE device, int32_t msgCode, VK_DBG_MSG_FILTER filter)
{
- XGL_RESULT result = nextTable.DbgSetMessageFilter(device, msgCode, filter);
+ VK_RESULT result = nextTable.DbgSetMessageFilter(device, msgCode, filter);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetObjectTag(XGL_BASE_OBJECT object, size_t tagSize, const void* pTag)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetObjectTag(VK_BASE_OBJECT object, size_t tagSize, const void* pTag)
{
- XGL_RESULT result = nextTable.DbgSetObjectTag(object, tagSize, pTag);
+ VK_RESULT result = nextTable.DbgSetObjectTag(object, tagSize, pTag);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption(XGL_INSTANCE instance, XGL_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetGlobalOption(VK_INSTANCE instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData)
{
- XGL_RESULT result = nextTable.DbgSetGlobalOption(instance, dbgOption, dataSize, pData);
+ VK_RESULT result = nextTable.DbgSetGlobalOption(instance, dbgOption, dataSize, pData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetDeviceOption(XGL_DEVICE device, XGL_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetDeviceOption(VK_DEVICE device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData)
{
- XGL_RESULT result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData);
+ VK_RESULT result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData);
return result;
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDbgMarkerBegin(XGL_CMD_BUFFER cmdBuffer, const char* pMarker)
+VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VK_CMD_BUFFER cmdBuffer, const char* pMarker)
{
nextTable.CmdDbgMarkerBegin(cmdBuffer, pMarker);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdDbgMarkerEnd(XGL_CMD_BUFFER cmdBuffer)
+VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VK_CMD_BUFFER cmdBuffer)
{
nextTable.CmdDbgMarkerEnd(cmdBuffer);
@@ -1930,43 +1931,43 @@
#if defined(__linux__) || defined(XCB_NVIDIA)
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11AssociateConnection(XGL_PHYSICAL_GPU gpu, const XGL_WSI_X11_CONNECTION_INFO* pConnectionInfo)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11AssociateConnection(VK_PHYSICAL_GPU gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
pCurObj = gpuw;
loader_platform_thread_once(&tabOnce, initParamChecker);
- XGL_RESULT result = nextTable.WsiX11AssociateConnection((XGL_PHYSICAL_GPU)gpuw->nextObject, pConnectionInfo);
+ VK_RESULT result = nextTable.WsiX11AssociateConnection((VK_PHYSICAL_GPU)gpuw->nextObject, pConnectionInfo);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11GetMSC(XGL_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11GetMSC(VK_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc)
{
- XGL_RESULT result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc);
+ VK_RESULT result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11CreatePresentableImage(XGL_DEVICE device, const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11CreatePresentableImage(VK_DEVICE device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem)
{
- XGL_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
+ VK_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11QueuePresent(XGL_QUEUE queue, const XGL_WSI_X11_PRESENT_INFO* pPresentInfo, XGL_FENCE fence)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11QueuePresent(VK_QUEUE queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VK_FENCE fence)
{
- XGL_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
+ VK_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
return result;
}
#endif
-#include "xgl_generic_intercept_proc_helper.h"
-XGL_LAYER_EXPORT void* XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* funcName)
+#include "vk_generic_intercept_proc_helper.h"
+VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName)
{
- XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+ VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
void* addr;
if (gpu == NULL)
return NULL;
@@ -1979,7 +1980,7 @@
else {
if (gpuw->pGPA == NULL)
return NULL;
- return gpuw->pGPA((XGL_PHYSICAL_GPU)gpuw->nextObject, funcName);
+ return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName);
}
}