layers: Layers now compiling on rename branch, still need to test but cube is currenting hitting segF by itself

4 files changed, 85 insertions, 85 deletions

diff --git a/layers/glave_snapshot.c b/layers/glave_snapshot.c
index 2c351573..dabb414b 100644
--- a/layers/glave_snapshot.c
+++ b/layers/glave_snapshot.c
@@ -33,7 +33,7 @@
 #define LAYER_ABBREV_STR "GLVSnap"
 
 static VkLayerDispatchTable nextTable;
-static VK_BASE_LAYER_OBJECT *pCurObj;
+static VkBaseLayerObject *pCurObj;
 
 // The following is #included again to catch certain OS-specific functions being used:
 #include "loader_platform.h"
@@ -492,7 +492,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkEnumerateGpus(VkInstance instance, uint32_t max
 
 VK_LAYER_EXPORT VkResult VKAPI vkGetGpuInfo(VkPhysicalGpu gpu, VkPhysicalGpuInfoType infoType, size_t* pDataSize, void* pData)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
     VkResult result = nextTable.GetGpuInfo((VkPhysicalGpu)gpuw->nextObject, infoType, pDataSize, pData);
@@ -501,7 +501,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetGpuInfo(VkPhysicalGpu gpu, VkPhysicalGpuInfo
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
     VkResult result = nextTable.CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice);
@@ -543,7 +543,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device)
 
 VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)gpu, VK_OBJECT_TYPE_PHYSICAL_GPU);
     loader_platform_thread_unlock_mutex(&objLock);
@@ -556,7 +556,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const ch
 VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
 {
     if (gpu != NULL) {
-        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+        VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
         loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)gpu, VK_OBJECT_TYPE_PHYSICAL_GPU);
     loader_platform_thread_unlock_mutex(&objLock);
@@ -670,7 +670,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkPinSystemMemory(VkDevice device, const void* pS
 
 VK_LAYER_EXPORT VkResult VKAPI vkGetMultiGpuCompatibility(VkPhysicalGpu gpu0, VkPhysicalGpu gpu1, VkGpuCompatibilityInfo* pInfo)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu0;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu0;
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)gpu0, VK_OBJECT_TYPE_PHYSICAL_GPU);
     loader_platform_thread_unlock_mutex(&objLock);
@@ -1181,7 +1181,7 @@ VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VkDescriptorSet descriptorSet, ui
     nextTable.UpdateDescriptors(descriptorSet, updateCount, ppUpdateArray);
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpStateObject* pState)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState)
 {
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
@@ -1197,7 +1197,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, con
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsStateObject* pState)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState)
 {
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
@@ -1213,7 +1213,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbStateObject* pState)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState)
 {
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
@@ -1229,7 +1229,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, c
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsStateObject* pState)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState)
 {
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
@@ -1702,7 +1702,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer)
 
 VK_LAYER_EXPORT VkResult VKAPI vkWsiX11AssociateConnection(VkPhysicalGpu gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)gpu, VK_OBJECT_TYPE_PHYSICAL_GPU);
     loader_platform_thread_unlock_mutex(&objLock);
@@ -1894,7 +1894,7 @@ void glvSnapshotPrintObjects(void)
 #include "vk_generic_intercept_proc_helper.h"
 VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
     void* addr;
     if (gpu == NULL)
         return NULL;
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 189b87aa..152a4e95 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -144,13 +144,13 @@ static uint64_t addFenceInfo(VkFence fence, VkQueue queue)
         // Validate that fence is in UNSIGNALED state
         MT_OBJ_INFO* pObjectInfo = getObjectInfo(fence);
         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, "Fence %p submitted in SIGNALED state.  Fences must be reset before being submitted", fence);
-                layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
+                layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
             }
         }
-        pFenceInfo->localFence = XGL_FALSE;
+        pFenceInfo->localFence = VK_FALSE;
         pFenceInfo->fence      = fence;
     }
     pFenceInfo->queue = queue;
@@ -199,7 +199,7 @@ static void updateFenceTracking(VkFence fence)
             MT_OBJ_INFO* pObjectInfo = getObjectInfo(fence);
             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<VkFenceCreateFlags>(pObjectInfo->create_info.fence_create_info.flags | VK_FENCE_CREATE_SIGNALED_BIT);
             }
         }
     }
@@ -1230,15 +1230,15 @@ VK_LAYER_EXPORT VkResult VKAPI vkResetFences(VkDevice device, uint32_t fenceCoun
             MT_OBJ_INFO* pObjectInfo = getObjectInfo(pFences[i]);
             if (pObjectInfo != NULL) {
                 // Validate fences in SIGNALED state
-                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, "Fence %p submitted to xglResetFences in UNSIGNALED STATE", pFences[i]);
-                    layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
-                    result = XGL_ERROR_INVALID_VALUE;
+                    layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
+                    result = VK_ERROR_INVALID_VALUE;
                 }
                 else {
                     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<VkFenceCreateFlags>(pObjectInfo->create_info.fence_create_info.flags & ~VK_FENCE_CREATE_SIGNALED_BIT);
                 }
             }
         }
@@ -1264,10 +1264,10 @@ VK_LAYER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCo
     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 fence %p already in SIGNALED state.", pFences[i]);
-                layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
+                layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
             }
         }
     }
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index e7c7e63b..c3cc8392 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -1733,18 +1733,6 @@ void PreCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateI
         return;
     }
 
-    for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
-    {
-        if(!validate_VK_ATTACHMENT_STORE_OP(pCreateInfo->pColorStoreOps[i]))
-        {
-            std::stringstream ss;
-            ss << "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP pCreateInfo->pColorStoreOps[" << i <<
-                "], is unrecognized (precondition).";
-            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[] = "vkCreateRenderPass parameter, VK_CLEAR_COLOR* pCreateInfo->"\
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index a9d9a330..d9a75814 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -123,7 +123,7 @@ class Subcommand(object):
             return ("%f", name)
         if "bool" in vk_type or 'xcb_randr_crtc_t' in vk_type:
             return ("%u", name)
-        if True in [t in vk_type for t in ["int", "FLAGS", "MASK", "xcb_window_t"]]:
+        if True in [t in vk_type.lower() for t in ["int", "flags", "mask", "xcb_window_t"]]:
             if '[' in vk_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
                 if cpp:
                     return ("[%i, %i, %i, %i]", "%s[0] << %s[1] << %s[2] << %s[3]" % (name, name, name, name))
@@ -241,6 +241,28 @@ class Subcommand(object):
         ggei_body.append('}')
         return "\n".join(ggei_body)
 
+    def _gen_layer_get_extension_support(self, layer="Generic"):
+        ges_body = []
+        ges_body.append('VK_LAYER_EXPORT VkResult VKAPI xglGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName)')
+        ges_body.append('{')
+        ges_body.append('    VkResult result;')
+        ges_body.append('    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;')
+        ges_body.append('')
+        ges_body.append('    /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */')
+        ges_body.append('    if (!strncmp(pExtName, "%s", strlen("%s")))' % (layer, layer))
+        ges_body.append('    {')
+        ges_body.append('        result = VK_SUCCESS;')
+        ges_body.append('    } else if (nextTable.GetExtensionSupport != NULL)')
+        ges_body.append('    {')
+        ges_body.append('        result = nextTable.GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName);')
+        ges_body.append('    } else')
+        ges_body.append('    {')
+        ges_body.append('        result = VK_ERROR_INVALID_EXTENSION;')
+        ges_body.append('    }')
+        ges_body.append('    return result;')
+        ges_body.append('}')
+        return "\n".join(ges_body)
+
     def _generate_dispatch_entrypoints(self, qual=""):
         if qual:
             qual += " "
@@ -305,13 +327,13 @@ class Subcommand(object):
         exts = []
         exts.append('uint64_t objTrackGetObjectCount(VK_OBJECT_TYPE type)')
         exts.append('{')
-        exts.append('    return (type == VK_OBJECT_TYPE_ANY) ? numTotalObjs : numObjs[type];')
+        exts.append('    return (type == VkObjectTypeAny) ? numTotalObjs : numObjs[type];')
         exts.append('}')
         exts.append('')
         exts.append('VkResult objTrackGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray)')
         exts.append('{')
         exts.append("    // This bool flags if we're pulling all objs or just a single class of objs")
-        exts.append('    bool32_t bAllObjs = (type == VK_OBJECT_TYPE_ANY);')
+        exts.append('    bool32_t bAllObjs = (type == VkObjectTypeAny);')
         exts.append('    // Check the count first thing')
         exts.append('    uint64_t maxObjCount = (bAllObjs) ? numTotalObjs : numObjs[type];')
         exts.append('    if (objCount > maxObjCount) {')
@@ -333,28 +355,29 @@ class Subcommand(object):
         exts.append('    }')
         exts.append('    return VK_SUCCESS;')
         exts.append('}')
-
-    def _generate_layer_gpa_function(self, extensions=[]):
-        func_body = []
-        func_body.append("VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName)\n"
-                         "{\n"
-                         "    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;\n"
-                         "    void* addr;\n"
-                         "    if (gpu == NULL)\n"
-                         "        return NULL;\n"
-                         "    pCurObj = gpuw;\n"
-                         "    loader_platform_thread_once(&tabOnce, init%s);\n\n"
-                         "    addr = layer_intercept_proc(funcName);\n"
-                         "    if (addr)\n"
-                         "        return addr;" % self.layer_name)
-
         return "\n".join(exts)
 
+#    def _generate_layer_gpa_function(self, extensions=[]):
+#        func_body = []
+#        func_body.append("VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName)\n"
+#                         "{\n"
+#                         "    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;\n"
+#                         "    void* addr;\n"
+#                         "    if (gpu == NULL)\n"
+#                         "        return NULL;\n"
+#                         "    pCurObj = gpuw;\n"
+#                         "    loader_platform_thread_once(&tabOnce, init%s);\n\n"
+#                         "    addr = layer_intercept_proc(funcName);\n"
+#                         "    if (addr)\n"
+#                         "        return addr;" % self.layer_name)
+#
+#        return "\n".join(exts)
+
     def _generate_layer_gpa_function(self, extensions=[]):
         func_body = []
         func_body.append("VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName)\n"
                          "{\n"
-                         "    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;\n"
+                         "    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;\n"
                          "    void* addr;\n"
                          "    if (gpu == NULL)\n"
                          "        return NULL;\n"
@@ -677,7 +700,6 @@ class APIDumpSubcommand(Subcommand):
                 sp_param_dict[pindex] = '*pCount'
             elif 'Wsi' not in proto.name and vk_helper.is_type(p.ty.strip('*').replace('const ', ''), 'struct'):
                 sp_param_dict[pindex] = 'index'
-            pindex += 1
             if p.name.endswith('Count'):
                 if '*' in p.ty:
                     prev_count_name = "*%s" % p.name
@@ -685,20 +707,7 @@ class APIDumpSubcommand(Subcommand):
                     prev_count_name = p.name
             else:
                 log_func_no_addr += '%s = " << %s << ", ' % (p.name, pfi)
-            if prev_count_name != '' and (prev_count_name.replace('Count', '')[1:] in p.name or 'slotCount' == prev_count_name):
-                sp_param_dict[pindex] = prev_count_name
-            elif 'pDescriptorSets' == p.name and proto.params[-1].name == 'pCount':
-                sp_param_dict[pindex] = '*pCount'
-            elif 'Wsi' not in proto.name and vk_helper.is_type(p.ty.strip('*').replace('const ', ''), 'struct'):
-                sp_param_dict[pindex] = 'index'
             pindex += 1
-            if p.name.endswith('Count'):
-                if '*' in p.ty:
-                    prev_count_name = "*%s" % p.name
-                else:
-                    prev_count_name = p.name
-            else:
-                prev_count_name = ''
         log_func = log_func.strip(', ')
         log_func_no_addr = log_func_no_addr.strip(', ')
         if proto.ret != "void":
@@ -710,10 +719,12 @@ class APIDumpSubcommand(Subcommand):
         log_func += ';'
         log_func_no_addr += ';'
         log_func += '\n    }\n    else {%s;\n    }' % log_func_no_addr;
+        #print("Proto %s has param_dict: %s" % (proto.name, sp_param_dict))
         if len(sp_param_dict) > 0:
             i_decl = False
             log_func += '\n    string tmp_str;'
             for sp_index in sp_param_dict:
+                #print("sp_index: %s" % str(sp_index))
                 if 'index' == sp_param_dict[sp_index]:
                     cis_print_func = 'vk_print_%s' % (proto.params[sp_index].ty.replace('const ', '').strip('*').lower())
                     local_name = proto.params[sp_index].name
@@ -783,26 +794,27 @@ class APIDumpSubcommand(Subcommand):
                          '    }\n'
                          '%s'
                          '}' % (qual, decl, self.layer_name, self.layer_name, proto.c_call(), f_open, log_func, f_close, stmt))
-        else:
+        
+        elif 'vkphysicalgpu' == proto.params[0].ty.lower():
+            c_call = proto.c_call().replace("(" + proto.params[0].name, "((VkPhysicalGpu)gpuw->nextObject", 1)
             funcs.append('%s%s\n'
                      '{\n'
                      '    using namespace StreamControl;\n'
+                     '    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) %s;\n'
+                     '    pCurObj = gpuw;\n'
+                     '    loader_platform_thread_once(&tabOnce, init%s);\n'
                      '    %snextTable.%s;\n'
                      '    %s%s%s\n'
                      '%s'
-                     '}' % (qual, decl, ret_val, proto.c_call(), f_open, log_func, f_close, stmt))
+                     '}' % (qual, decl, proto.params[0].name, self.layer_name, ret_val, c_call, f_open, log_func, f_close, stmt))
         else:
-            c_call = proto.c_call().replace("(" + proto.params[0].name, "((VkPhysicalGpu)gpuw->nextObject", 1)
             funcs.append('%s%s\n'
                      '{\n'
                      '    using namespace StreamControl;\n'
-                     '    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
-                     '    pCurObj = gpuw;\n'
-                     '    loader_platform_thread_once(&tabOnce, init%s);\n'
                      '    %snextTable.%s;\n'
                      '    %s%s%s\n'
                      '%s'
-                     '}' % (qual, decl, proto.params[0].name, self.layer_name, ret_val, c_call, f_open, log_func, f_close, stmt))
+                     '}' % (qual, decl, ret_val, proto.c_call(), f_open, log_func, f_close, stmt))
         if 'WsiX11QueuePresent' == proto.name:
             funcs.append("#endif")
         return "\n\n".join(funcs)
@@ -824,7 +836,7 @@ class APIDumpSubcommand(Subcommand):
 #        header_txt.append('// The following is #included again to catch certain OS-specific functions being used:')
 #        header_txt.append('#include "loader_platform.h"')
 #        header_txt.append('static VkLayerDispatchTable nextTable;')
-#        header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n')
+#        header_txt.append('static VkBaseLayerObject *pCurObj;\n')
 #        header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);')
 #        header_txt.append('static int printLockInitialized = 0;')
 #        header_txt.append('static loader_platform_thread_mutex printLock;\n')
@@ -1303,7 +1315,7 @@ class ObjectTrackerSubcommand(Subcommand):
         if proto.name in [ 'DbgRegisterMsgCallback', 'DbgUnregisterMsgCallback', 'GetGlobalExtensionInfo' ]:
             # use default version
             return None
-        obj_type_mapping = {base_t : base_t.replace("VK_", "VK_OBJECT_TYPE_") for base_t in vulkan.object_type_list}
+        obj_type_mapping = {base_t : base_t.replace("Vk", "VkObjectType") for base_t in vulkan.object_type_list}
         # For the various "super-types" we have to use function to distinguish sub type
         for obj_type in ["VK_BASE_OBJECT", "VK_OBJECT", "VK_DYNAMIC_STATE_OBJECT", "VkObject", "VkBaseObject"]:
             obj_type_mapping[obj_type] = "ll_get_obj_type(object)"
@@ -1322,15 +1334,15 @@ class ObjectTrackerSubcommand(Subcommand):
             using_line += '    ll_increment_use_count((void*)%s, %s);\n' % (param0_name, obj_type_mapping[p0_type])
             using_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
         if 'QueueSubmit' in proto.name:
-            using_line += '    set_status((void*)fence, VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED);\n'
+            using_line += '    set_status((void*)fence, VkObjectTypeFence, OBJSTATUS_FENCE_IS_SUBMITTED);\n'
             using_line += '    // TODO: Fix for updated memory reference mechanism\n'
             using_line += '    // validate_memory_mapping_status(pMemRefs, memRefCount);\n'
             using_line += '    // validate_mem_ref_count(memRefCount);\n'
         elif 'GetFenceStatus' in proto.name:
             using_line += '    // Warn if submitted_flag is not set\n'
-            using_line += '    validate_status((void*)fence, VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED, OBJSTATUS_FENCE_IS_SUBMITTED, VK_DBG_MSG_ERROR, OBJTRACK_INVALID_FENCE, "Status Requested for Unsubmitted Fence");\n'
+            using_line += '    validate_status((void*)fence, VkObjectTypeFence, OBJSTATUS_FENCE_IS_SUBMITTED, OBJSTATUS_FENCE_IS_SUBMITTED, VK_DBG_MSG_ERROR, OBJTRACK_INVALID_FENCE, "Status Requested for Unsubmitted Fence");\n'
         elif 'EndCommandBuffer' in proto.name:
-            using_line += '    reset_status((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER, (OBJSTATUS_VIEWPORT_BOUND    |\n'
+            using_line += '    reset_status((void*)cmdBuffer, VkObjectTypeCmdBuffer, (OBJSTATUS_VIEWPORT_BOUND    |\n'
             using_line += '                                                                OBJSTATUS_RASTER_BOUND      |\n'
             using_line += '                                                                OBJSTATUS_COLOR_BLEND_BOUND |\n'
             using_line += '                                                                OBJSTATUS_DEPTH_STENCIL_BOUND));\n'
@@ -1339,20 +1351,20 @@ class ObjectTrackerSubcommand(Subcommand):
         elif 'CmdDraw' in proto.name:
             using_line += '    validate_draw_state_flags((void *)cmdBuffer);\n'
         elif 'MapMemory' in proto.name:
-            using_line += '    set_status((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);\n'
+            using_line += '    set_status((void*)mem, VkObjectTypeGpuMemory, OBJSTATUS_GPU_MEM_MAPPED);\n'
         elif 'UnmapMemory' in proto.name:
-            using_line += '    reset_status((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);\n'
+            using_line += '    reset_status((void*)mem, VkObjectTypeGpuMemory, OBJSTATUS_GPU_MEM_MAPPED);\n'
         if 'AllocDescriptor' in proto.name: # Allocates array of DSs
             create_line =  '    for (uint32_t i = 0; i < *pCount; i++) {\n'
             create_line += '        loader_platform_thread_lock_mutex(&objLock);\n'
-            create_line += '        ll_insert_obj((void*)pDescriptorSets[i], VK_OBJECT_TYPE_DESCRIPTOR_SET);\n'
+            create_line += '        ll_insert_obj((void*)pDescriptorSets[i], VkObjectTypeDescriptorSet);\n'
             create_line += '        loader_platform_thread_unlock_mutex(&objLock);\n'
             create_line += '    }\n'
         elif 'CreatePresentableImage' in proto.name:
             create_line = '    loader_platform_thread_lock_mutex(&objLock);\n'
             create_line += '    ll_insert_obj((void*)*%s, %s);\n' % (proto.params[-2].name, obj_type_mapping[proto.params[-2].ty.strip('*').replace('const ', '')])
-            create_line += '    ll_insert_obj((void*)*pMem, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);\n'
-            # create_line += '    ll_insert_obj((void*)*%s, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);\n' % (obj_type_mapping[proto.params[-1].ty.strip('*').replace('const ', '')])
+            create_line += '    ll_insert_obj((void*)*pMem, VkObjectTypePresentableImageMemory);\n'
+            # create_line += '    ll_insert_obj((void*)*%s, VkObjectTypePresentableImageMemory);\n' % (obj_type_mapping[proto.params[-1].ty.strip('*').replace('const ', '')])
             create_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
         elif 'Create' in proto.name or 'Alloc' in proto.name:
             create_line = '    loader_platform_thread_lock_mutex(&objLock);\n'
@@ -1371,7 +1383,7 @@ class ObjectTrackerSubcommand(Subcommand):
                 using_line = ''
             if 'DestroyDevice' in proto.name:
                 destroy_line += '    // Report any remaining objects in LL\n    objNode *pTrav = pGlobalHead;\n    while (pTrav) {\n'
-                destroy_line += '        if (pTrav->obj.objType == VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY) {\n'
+                destroy_line += '        if (pTrav->obj.objType == VkObjectTypePresentableImageMemory) {\n'
                 destroy_line += '            objNode *pDel = pTrav;\n'
                 destroy_line += '            pTrav = pTrav->pNextGlobal;\n'
                 destroy_line += '            ll_destroy_obj((void*)(pDel->obj.pObj));\n'