diff --git a/CMakeLists.txt b/CMakeLists.txt
index 76fc7fd..d0b135e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -170,23 +170,13 @@
 # Use the macro to generate the source files.
 GenerateFromVkXml(vk_layer_dispatch_table.h loader_extension_generator.py)
 GenerateFromVkXml(vk_dispatch_table_helper.h dispatch_table_helper_generator.py)
-GenerateFromVkXml(vk_safe_struct.h helper_file_generator.py)
-GenerateFromVkXml(vk_safe_struct.cpp helper_file_generator.py)
-GenerateFromVkXml(vk_enum_string_helper.h helper_file_generator.py)
 GenerateFromVkXml(vk_object_types.h helper_file_generator.py)
-GenerateFromVkXml(vk_extension_helper.h helper_file_generator.py)
-GenerateFromVkXml(vk_typemap_helper.h helper_file_generator.py)
 
 # Use a custom target to cause the source files to be generated.
 add_custom_target(generate_helper_files
-                  DEPENDS vk_enum_string_helper.h
-                          vk_safe_struct.h
-                          vk_safe_struct.cpp
-                          vk_object_types.h
+                  DEPENDS vk_object_types.h
                           vk_layer_dispatch_table.h
-                          vk_dispatch_table_helper.h
-                          vk_extension_helper.h
-                          vk_typemap_helper.h)
+                          vk_dispatch_table_helper.h)
 
 set_target_properties(generate_helper_files PROPERTIES FOLDER ${LOADER_HELPER_FOLDER})
 
diff --git a/scripts/helper_file_generator.py b/scripts/helper_file_generator.py
index bfdcab3..56045ee 100644
--- a/scripts/helper_file_generator.py
+++ b/scripts/helper_file_generator.py
@@ -385,266 +385,6 @@
         outstring += '}\n'
         return outstring
     #
-    # Tack on a helper which, given an index into a VkPhysicalDeviceFeatures structure, will print the corresponding feature name
-    def DeIndexPhysDevFeatures(self):
-        pdev_members = None
-        for name, members, ifdef in self.structMembers:
-            if name == 'VkPhysicalDeviceFeatures':
-                pdev_members = members
-                break
-        deindex = '\n'
-        deindex += 'static inline const char * GetPhysDevFeatureString(uint32_t index) {\n'
-        deindex += '    const char * IndexToPhysDevFeatureString[] = {\n'
-        for feature in pdev_members:
-            deindex += '        "%s",\n' % feature.name
-        deindex += '    };\n\n'
-        deindex += '    return IndexToPhysDevFeatureString[index];\n'
-        deindex += '}\n'
-        return deindex
-    #
-    # Combine enum string helper header file preamble with body text and return
-    def GenerateEnumStringHelperHeader(self):
-            enum_string_helper_header = '\n'
-            enum_string_helper_header += '#pragma once\n'
-            enum_string_helper_header += '#ifdef _WIN32\n'
-            enum_string_helper_header += '#pragma warning( disable : 4065 )\n'
-            enum_string_helper_header += '#endif\n'
-            enum_string_helper_header += '\n'
-            enum_string_helper_header += '#include <vulkan/vulkan.h>\n'
-            enum_string_helper_header += '\n'
-            enum_string_helper_header += self.enum_output
-            enum_string_helper_header += self.DeIndexPhysDevFeatures()
-            return enum_string_helper_header
-    #
-    # Helper function for declaring a counter variable only once
-    def DeclareCounter(self, string_var, declare_flag):
-        if declare_flag == False:
-            string_var += '        uint32_t i = 0;\n'
-            declare_flag = True
-        return string_var, declare_flag
-    #
-    # Combine safe struct helper header file preamble with body text and return
-    def GenerateSafeStructHelperHeader(self):
-        safe_struct_helper_header = '\n'
-        safe_struct_helper_header += '#pragma once\n'
-        safe_struct_helper_header += '#include <vulkan/vulkan.h>\n'
-        safe_struct_helper_header += '\n'
-        safe_struct_helper_header += self.GenerateSafeStructHeader()
-        return safe_struct_helper_header
-    #
-    # safe_struct header: build function prototypes for header file
-    def GenerateSafeStructHeader(self):
-        safe_struct_header = ''
-        for item in self.structMembers:
-            if self.NeedSafeStruct(item) == True:
-                safe_struct_header += '\n'
-                if item.ifdef_protect is not None:
-                    safe_struct_header += '#ifdef %s\n' % item.ifdef_protect
-                safe_struct_header += 'struct safe_%s {\n' % (item.name)
-                for member in item.members:
-                    if member.type in self.structNames:
-                        member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == member.type), None)
-                        if member_index is not None and self.NeedSafeStruct(self.structMembers[member_index]) == True:
-                            if member.ispointer:
-                                safe_struct_header += '    safe_%s* %s;\n' % (member.type, member.name)
-                            else:
-                                safe_struct_header += '    safe_%s %s;\n' % (member.type, member.name)
-                            continue
-                    if member.len is not None and (self.TypeContainsObjectHandle(member.type, True) or self.TypeContainsObjectHandle(member.type, False)):
-                            safe_struct_header += '    %s* %s;\n' % (member.type, member.name)
-                    else:
-                        safe_struct_header += '%s;\n' % member.cdecl
-                safe_struct_header += '    safe_%s(const %s* in_struct%s);\n' % (item.name, item.name, self.custom_construct_params.get(item.name, ''))
-                safe_struct_header += '    safe_%s(const safe_%s& src);\n' % (item.name, item.name)
-                safe_struct_header += '    safe_%s& operator=(const safe_%s& src);\n' % (item.name, item.name)
-                safe_struct_header += '    safe_%s();\n' % item.name
-                safe_struct_header += '    ~safe_%s();\n' % item.name
-                safe_struct_header += '    void initialize(const %s* in_struct%s);\n' % (item.name, self.custom_construct_params.get(item.name, ''))
-                safe_struct_header += '    void initialize(const safe_%s* src);\n' % (item.name)
-                safe_struct_header += '    %s *ptr() { return reinterpret_cast<%s *>(this); }\n' % (item.name, item.name)
-                safe_struct_header += '    %s const *ptr() const { return reinterpret_cast<%s const *>(this); }\n' % (item.name, item.name)
-                safe_struct_header += '};\n'
-                if item.ifdef_protect is not None:
-                    safe_struct_header += '#endif // %s\n' % item.ifdef_protect
-        return safe_struct_header
-    #
-    # Generate extension helper header file
-    def GenerateExtensionHelperHeader(self):
-
-        V_1_0_instance_extensions_promoted_to_core = [
-            'vk_khr_device_group_creation',
-            'vk_khr_external_fence_capabilities',
-            'vk_khr_external_memory_capabilities',
-            'vk_khr_external_semaphore_capabilities',
-            'vk_khr_get_physical_device_properties_2',
-            ]
-
-        V_1_0_device_extensions_promoted_to_core = [
-            'vk_khr_16bit_storage',
-            'vk_khr_bind_memory_2',
-            'vk_khr_dedicated_allocation',
-            'vk_khr_descriptor_update_template',
-            'vk_khr_device_group',
-            'vk_khr_external_fence',
-            'vk_khr_external_memory',
-            'vk_khr_external_semaphore',
-            'vk_khr_get_memory_requirements_2',
-            'vk_khr_maintenance1',
-            'vk_khr_maintenance2',
-            'vk_khr_maintenance3',
-            'vk_khr_multiview',
-            'vk_khr_relaxed_block_layout',
-            'vk_khr_sampler_ycbcr_conversion',
-            'vk_khr_shader_draw_parameters',
-            'vk_khr_storage_buffer_storage_class',
-            'vk_khr_variable_pointers',
-            ]
-
-        output = [
-            '',
-            '#ifndef VK_EXTENSION_HELPER_H_',
-            '#define VK_EXTENSION_HELPER_H_',
-            '#include <string>',
-            '#include <unordered_map>',
-            '#include <utility>',
-            '',
-            '#include <vulkan/vulkan.h>',
-            '']
-
-        def guarded(ifdef, value):
-            if ifdef is not None:
-                return '\n'.join([ '#ifdef %s' % ifdef, value, '#endif' ])
-            else:
-                return value
-
-        for type in ['Instance', 'Device']:
-            struct_type = '%sExtensions' % type
-            if type == 'Instance':
-                extension_dict = self.instance_extension_info
-                promoted_ext_list = V_1_0_instance_extensions_promoted_to_core
-                struct_decl = 'struct %s {' % struct_type
-                instance_struct_type = struct_type
-            else:
-                extension_dict = self.device_extension_info
-                promoted_ext_list = V_1_0_device_extensions_promoted_to_core
-                struct_decl = 'struct %s : public %s {' % (struct_type, instance_struct_type)
-
-            extension_items = sorted(extension_dict.items())
-
-            field_name = { ext_name: re.sub('_extension_name', '', info['define'].lower()) for ext_name, info in extension_items }
-            if type == 'Instance':
-                instance_field_name = field_name
-                instance_extension_dict = extension_dict
-            else:
-                # Get complete field name and extension data for both Instance and Device extensions
-                field_name.update(instance_field_name)
-                extension_dict = extension_dict.copy()  # Don't modify the self.<dict> we're pointing to
-                extension_dict.update(instance_extension_dict)
-
-            # Output the data member list
-            struct  = [struct_decl]
-            struct.extend([ '    bool %s{false};' % field_name[ext_name] for ext_name, info in extension_items])
-
-            # Construct the extension information map -- mapping name to data member (field), and required extensions
-            # The map is contained within a static function member for portability reasons.
-            info_type = '%sInfo' % type
-            info_map_type = '%sMap' % info_type
-            req_type = '%sReq' % type
-            req_vec_type = '%sVec' % req_type
-            struct.extend([
-                '',
-                '    struct %s {' % req_type,
-                '        const bool %s::* enabled;' % struct_type,
-                '        const char *name;',
-                '    };',
-                '    typedef std::vector<%s> %s;' % (req_type, req_vec_type),
-                '    struct %s {' % info_type,
-                '       %s(bool %s::* state_, const %s requires_): state(state_), requires(requires_) {}' % ( info_type, struct_type, req_vec_type),
-                '       bool %s::* state;' % struct_type,
-                '       %s requires;' % req_vec_type,
-                '    };',
-                '',
-                '    typedef std::unordered_map<std::string,%s> %s;' % (info_type, info_map_type),
-                '    static const %s &get_info(const char *name) {' %info_type,
-                '        static const %s info_map = {' % info_map_type ])
-
-            field_format = '&' + struct_type + '::%s'
-            req_format = '{' + field_format+ ', %s}'
-            req_indent = '\n                           '
-            req_join = ',' + req_indent
-            info_format = ('            std::make_pair(%s, ' + info_type + '(' + field_format + ', {%s})),')
-            def format_info(ext_name, info):
-                reqs = req_join.join([req_format % (field_name[req], extension_dict[req]['define']) for req in info['reqs']])
-                return info_format % (info['define'], field_name[ext_name], '{%s}' % (req_indent + reqs) if reqs else '')
-
-            struct.extend([guarded(info['ifdef'], format_info(ext_name, info)) for ext_name, info in extension_items])
-            struct.extend([
-                '        };',
-                '',
-                '        static const %s empty_info {nullptr, %s()};' % (info_type, req_vec_type),
-                '        %s::const_iterator info = info_map.find(name);' % info_map_type,
-                '        if ( info != info_map.cend()) {',
-                '            return info->second;',
-                '        }',
-                '        return empty_info;',
-                '    }',
-                ''])
-
-            if type == 'Instance':
-                struct.extend([
-                    '    uint32_t NormalizeApiVersion(uint32_t specified_version) {',
-                    '        uint32_t api_version = (specified_version < VK_API_VERSION_1_1) ? VK_API_VERSION_1_0 : VK_API_VERSION_1_1;',
-                    '        return api_version;',
-                    '    }',
-                    '',
-                    '    uint32_t InitFromInstanceCreateInfo(uint32_t requested_api_version, const VkInstanceCreateInfo *pCreateInfo) {'])
-            else:
-                struct.extend([
-                    '    %s() = default;' % struct_type,
-                    '    %s(const %s& instance_ext) : %s(instance_ext) {}' % (struct_type, instance_struct_type, instance_struct_type),
-                    '',
-                    '    uint32_t InitFromDeviceCreateInfo(const %s *instance_extensions, uint32_t requested_api_version,' % instance_struct_type,
-                    '                                      const VkDeviceCreateInfo *pCreateInfo) {',
-                    '        // Initialize: this to defaults,  base class fields to input.',
-                    '        assert(instance_extensions);',
-                    '        *this = %s(*instance_extensions);' % struct_type])
-
-            struct.extend([
-                '',
-                '        static const std::vector<const char *> V_1_0_promoted_%s_extensions = {' % type.lower() ])
-            struct.extend(['            %s_EXTENSION_NAME,' % ext_name.upper() for ext_name in promoted_ext_list])
-            struct.extend([
-                '        };',
-                '',
-                '        // Initialize struct data, robust to invalid pCreateInfo',
-                '        if (pCreateInfo->ppEnabledExtensionNames) {',
-                '            for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {',
-                '                if (!pCreateInfo->ppEnabledExtensionNames[i]) continue;',
-                '                auto info = get_info(pCreateInfo->ppEnabledExtensionNames[i]);',
-                '                if(info.state) this->*(info.state) = true;',
-                '            }',
-                '        }',
-                '        uint32_t api_version = NormalizeApiVersion(requested_api_version);',
-                '        if (api_version >= VK_API_VERSION_1_1) {',
-                '            for (auto promoted_ext : V_1_0_promoted_%s_extensions) {' % type.lower(),
-                '                auto info = get_info(promoted_ext);',
-                '                assert(info.state);',
-                '                if (info.state) this->*(info.state) = true;',
-                '            }',
-                '        }',
-                '        return api_version;',
-                '    }',
-                '};'])
-
-            # Output reference lists of instance/device extension names
-            struct.extend(['', 'static const char * const k%sExtensionNames = ' % type])
-            struct.extend([guarded(info['ifdef'], '    %s' % info['define']) for ext_name, info in extension_items])
-            struct.extend([';', ''])
-            output.extend(struct)
-
-        output.extend(['', '#endif // VK_EXTENSION_HELPER_H_'])
-        return '\n'.join(output)
-    #
     # Combine object types helper header file preamble with body text and return
     def GenerateObjectTypesHelperHeader(self):
         object_types_helper_header = '\n'
@@ -763,481 +503,11 @@
         object_types_header += '    return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;\n'
         object_types_header += '}\n'
         return object_types_header
-    #
-    # Determine if a structure needs a safe_struct helper function
-    # That is, it has an sType or one of its members is a pointer
-    def NeedSafeStruct(self, structure):
-        if 'sType' == structure.name:
-            return True
-        for member in structure.members:
-            if member.ispointer == True:
-                return True
-        return False
-    #
-    # Combine safe struct helper source file preamble with body text and return
-    def GenerateSafeStructHelperSource(self):
-        safe_struct_helper_source = '\n'
-        safe_struct_helper_source += '#include "vk_safe_struct.h"\n'
-        safe_struct_helper_source += '#include <string.h>\n'
-        safe_struct_helper_source += '#ifdef VK_USE_PLATFORM_ANDROID_KHR\n'
-        safe_struct_helper_source += '#if __ANDROID_API__ < __ANDROID_API_O__\n'
-        safe_struct_helper_source += 'struct AHardwareBuffer {};\n'
-        safe_struct_helper_source += '#endif\n'
-        safe_struct_helper_source += '#endif\n'
-
-        safe_struct_helper_source += '\n'
-        safe_struct_helper_source += self.GenerateSafeStructSource()
-        return safe_struct_helper_source
-    #
-    # safe_struct source -- create bodies of safe struct helper functions
-    def GenerateSafeStructSource(self):
-        safe_struct_body = []
-        wsi_structs = ['VkXlibSurfaceCreateInfoKHR',
-                       'VkXcbSurfaceCreateInfoKHR',
-                       'VkWaylandSurfaceCreateInfoKHR',
-                       'VkMirSurfaceCreateInfoKHR',
-                       'VkAndroidSurfaceCreateInfoKHR',
-                       'VkWin32SurfaceCreateInfoKHR'
-                       ]
-        for item in self.structMembers:
-            if self.NeedSafeStruct(item) == False:
-                continue
-            if item.name in wsi_structs:
-                continue
-            if item.ifdef_protect is not None:
-                safe_struct_body.append("#ifdef %s\n" % item.ifdef_protect)
-            ss_name = "safe_%s" % item.name
-            init_list = ''          # list of members in struct constructor initializer
-            default_init_list = ''  # Default constructor just inits ptrs to nullptr in initializer
-            init_func_txt = ''      # Txt for initialize() function that takes struct ptr and inits members
-            construct_txt = ''      # Body of constuctor as well as body of initialize() func following init_func_txt
-            destruct_txt = ''
-
-            custom_construct_txt = {
-                # VkWriteDescriptorSet is special case because pointers may be non-null but ignored
-                'VkWriteDescriptorSet' :
-                    '    switch (descriptorType) {\n'
-                    '        case VK_DESCRIPTOR_TYPE_SAMPLER:\n'
-                    '        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:\n'
-                    '        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:\n'
-                    '        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:\n'
-                    '        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:\n'
-                    '        if (descriptorCount && in_struct->pImageInfo) {\n'
-                    '            pImageInfo = new VkDescriptorImageInfo[descriptorCount];\n'
-                    '            for (uint32_t i=0; i<descriptorCount; ++i) {\n'
-                    '                pImageInfo[i] = in_struct->pImageInfo[i];\n'
-                    '            }\n'
-                    '        }\n'
-                    '        break;\n'
-                    '        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:\n'
-                    '        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:\n'
-                    '        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:\n'
-                    '        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:\n'
-                    '        if (descriptorCount && in_struct->pBufferInfo) {\n'
-                    '            pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];\n'
-                    '            for (uint32_t i=0; i<descriptorCount; ++i) {\n'
-                    '                pBufferInfo[i] = in_struct->pBufferInfo[i];\n'
-                    '            }\n'
-                    '        }\n'
-                    '        break;\n'
-                    '        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:\n'
-                    '        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:\n'
-                    '        if (descriptorCount && in_struct->pTexelBufferView) {\n'
-                    '            pTexelBufferView = new VkBufferView[descriptorCount];\n'
-                    '            for (uint32_t i=0; i<descriptorCount; ++i) {\n'
-                    '                pTexelBufferView[i] = in_struct->pTexelBufferView[i];\n'
-                    '            }\n'
-                    '        }\n'
-                    '        break;\n'
-                    '        default:\n'
-                    '        break;\n'
-                    '    }\n',
-                'VkShaderModuleCreateInfo' :
-                    '    if (in_struct->pCode) {\n'
-                    '        pCode = reinterpret_cast<uint32_t *>(new uint8_t[codeSize]);\n'
-                    '        memcpy((void *)pCode, (void *)in_struct->pCode, codeSize);\n'
-                    '    }\n',
-                # VkGraphicsPipelineCreateInfo is special case because its pointers may be non-null but ignored
-                'VkGraphicsPipelineCreateInfo' :
-                    '    if (stageCount && in_struct->pStages) {\n'
-                    '        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];\n'
-                    '        for (uint32_t i=0; i<stageCount; ++i) {\n'
-                    '            pStages[i].initialize(&in_struct->pStages[i]);\n'
-                    '        }\n'
-                    '    }\n'
-                    '    if (in_struct->pVertexInputState)\n'
-                    '        pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);\n'
-                    '    else\n'
-                    '        pVertexInputState = NULL;\n'
-                    '    if (in_struct->pInputAssemblyState)\n'
-                    '        pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(in_struct->pInputAssemblyState);\n'
-                    '    else\n'
-                    '        pInputAssemblyState = NULL;\n'
-                    '    bool has_tessellation_stage = false;\n'
-                    '    if (stageCount && pStages)\n'
-                    '        for (uint32_t i=0; i<stageCount && !has_tessellation_stage; ++i)\n'
-                    '            if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)\n'
-                    '                has_tessellation_stage = true;\n'
-                    '    if (in_struct->pTessellationState && has_tessellation_stage)\n'
-                    '        pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState);\n'
-                    '    else\n'
-                    '        pTessellationState = NULL; // original pTessellationState pointer ignored\n'
-                    '    bool has_rasterization = in_struct->pRasterizationState ? !in_struct->pRasterizationState->rasterizerDiscardEnable : false;\n'
-                    '    if (in_struct->pViewportState && has_rasterization) {\n'
-                    '        bool is_dynamic_viewports = false;\n'
-                    '        bool is_dynamic_scissors = false;\n'
-                    '        if (in_struct->pDynamicState && in_struct->pDynamicState->pDynamicStates) {\n'
-                    '            for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_viewports; ++i)\n'
-                    '                if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_VIEWPORT)\n'
-                    '                    is_dynamic_viewports = true;\n'
-                    '            for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_scissors; ++i)\n'
-                    '                if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_SCISSOR)\n'
-                    '                    is_dynamic_scissors = true;\n'
-                    '        }\n'
-                    '        pViewportState = new safe_VkPipelineViewportStateCreateInfo(in_struct->pViewportState, is_dynamic_viewports, is_dynamic_scissors);\n'
-                    '    } else\n'
-                    '        pViewportState = NULL; // original pViewportState pointer ignored\n'
-                    '    if (in_struct->pRasterizationState)\n'
-                    '        pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(in_struct->pRasterizationState);\n'
-                    '    else\n'
-                    '        pRasterizationState = NULL;\n'
-                    '    if (in_struct->pMultisampleState && has_rasterization)\n'
-                    '        pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(in_struct->pMultisampleState);\n'
-                    '    else\n'
-                    '        pMultisampleState = NULL; // original pMultisampleState pointer ignored\n'
-                    '    // needs a tracked subpass state uses_depthstencil_attachment\n'
-                    '    if (in_struct->pDepthStencilState && has_rasterization && uses_depthstencil_attachment)\n'
-                    '        pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(in_struct->pDepthStencilState);\n'
-                    '    else\n'
-                    '        pDepthStencilState = NULL; // original pDepthStencilState pointer ignored\n'
-                    '    // needs a tracked subpass state usesColorAttachment\n'
-                    '    if (in_struct->pColorBlendState && has_rasterization && uses_color_attachment)\n'
-                    '        pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(in_struct->pColorBlendState);\n'
-                    '    else\n'
-                    '        pColorBlendState = NULL; // original pColorBlendState pointer ignored\n'
-                    '    if (in_struct->pDynamicState)\n'
-                    '        pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState);\n'
-                    '    else\n'
-                    '        pDynamicState = NULL;\n',
-                 # VkPipelineViewportStateCreateInfo is special case because its pointers may be non-null but ignored
-                'VkPipelineViewportStateCreateInfo' :
-                    '    if (in_struct->pViewports && !is_dynamic_viewports) {\n'
-                    '        pViewports = new VkViewport[in_struct->viewportCount];\n'
-                    '        memcpy ((void *)pViewports, (void *)in_struct->pViewports, sizeof(VkViewport)*in_struct->viewportCount);\n'
-                    '    }\n'
-                    '    else\n'
-                    '        pViewports = NULL;\n'
-                    '    if (in_struct->pScissors && !is_dynamic_scissors) {\n'
-                    '        pScissors = new VkRect2D[in_struct->scissorCount];\n'
-                    '        memcpy ((void *)pScissors, (void *)in_struct->pScissors, sizeof(VkRect2D)*in_struct->scissorCount);\n'
-                    '    }\n'
-                    '    else\n'
-                    '        pScissors = NULL;\n',
-                # VkDescriptorSetLayoutBinding is special case because its pImmutableSamplers pointer may be non-null but ignored
-                'VkDescriptorSetLayoutBinding' :
-                    '    const bool sampler_type = in_struct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || in_struct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;\n'
-                    '    if (descriptorCount && in_struct->pImmutableSamplers && sampler_type) {\n'
-                    '        pImmutableSamplers = new VkSampler[descriptorCount];\n'
-                    '        for (uint32_t i=0; i<descriptorCount; ++i) {\n'
-                    '            pImmutableSamplers[i] = in_struct->pImmutableSamplers[i];\n'
-                    '        }\n'
-                    '    }\n',
-            }
-
-            custom_copy_txt = {
-                # VkGraphicsPipelineCreateInfo is special case because it has custom construct parameters
-                'VkGraphicsPipelineCreateInfo' :
-                    '    if (stageCount && src.pStages) {\n'
-                    '        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];\n'
-                    '        for (uint32_t i=0; i<stageCount; ++i) {\n'
-                    '            pStages[i].initialize(&src.pStages[i]);\n'
-                    '        }\n'
-                    '    }\n'
-                    '    if (src.pVertexInputState)\n'
-                    '        pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*src.pVertexInputState);\n'
-                    '    else\n'
-                    '        pVertexInputState = NULL;\n'
-                    '    if (src.pInputAssemblyState)\n'
-                    '        pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*src.pInputAssemblyState);\n'
-                    '    else\n'
-                    '        pInputAssemblyState = NULL;\n'
-                    '    bool has_tessellation_stage = false;\n'
-                    '    if (stageCount && pStages)\n'
-                    '        for (uint32_t i=0; i<stageCount && !has_tessellation_stage; ++i)\n'
-                    '            if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)\n'
-                    '                has_tessellation_stage = true;\n'
-                    '    if (src.pTessellationState && has_tessellation_stage)\n'
-                    '        pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*src.pTessellationState);\n'
-                    '    else\n'
-                    '        pTessellationState = NULL; // original pTessellationState pointer ignored\n'
-                    '    bool has_rasterization = src.pRasterizationState ? !src.pRasterizationState->rasterizerDiscardEnable : false;\n'
-                    '    if (src.pViewportState && has_rasterization) {\n'
-                    '        pViewportState = new safe_VkPipelineViewportStateCreateInfo(*src.pViewportState);\n'
-                    '    } else\n'
-                    '        pViewportState = NULL; // original pViewportState pointer ignored\n'
-                    '    if (src.pRasterizationState)\n'
-                    '        pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*src.pRasterizationState);\n'
-                    '    else\n'
-                    '        pRasterizationState = NULL;\n'
-                    '    if (src.pMultisampleState && has_rasterization)\n'
-                    '        pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*src.pMultisampleState);\n'
-                    '    else\n'
-                    '        pMultisampleState = NULL; // original pMultisampleState pointer ignored\n'
-                    '    if (src.pDepthStencilState && has_rasterization)\n'
-                    '        pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*src.pDepthStencilState);\n'
-                    '    else\n'
-                    '        pDepthStencilState = NULL; // original pDepthStencilState pointer ignored\n'
-                    '    if (src.pColorBlendState && has_rasterization)\n'
-                    '        pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*src.pColorBlendState);\n'
-                    '    else\n'
-                    '        pColorBlendState = NULL; // original pColorBlendState pointer ignored\n'
-                    '    if (src.pDynamicState)\n'
-                    '        pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*src.pDynamicState);\n'
-                    '    else\n'
-                    '        pDynamicState = NULL;\n',
-                 # VkPipelineViewportStateCreateInfo is special case because it has custom construct parameters
-                'VkPipelineViewportStateCreateInfo' :
-                    '    if (src.pViewports) {\n'
-                    '        pViewports = new VkViewport[src.viewportCount];\n'
-                    '        memcpy ((void *)pViewports, (void *)src.pViewports, sizeof(VkViewport)*src.viewportCount);\n'
-                    '    }\n'
-                    '    else\n'
-                    '        pViewports = NULL;\n'
-                    '    if (src.pScissors) {\n'
-                    '        pScissors = new VkRect2D[src.scissorCount];\n'
-                    '        memcpy ((void *)pScissors, (void *)src.pScissors, sizeof(VkRect2D)*src.scissorCount);\n'
-                    '    }\n'
-                    '    else\n'
-                    '        pScissors = NULL;\n',
-            }
-
-            custom_destruct_txt = {'VkShaderModuleCreateInfo' :
-                                   '    if (pCode)\n'
-                                   '        delete[] reinterpret_cast<const uint8_t *>(pCode);\n' }
-
-            for member in item.members:
-                m_type = member.type
-                if member.type in self.structNames:
-                    member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == member.type), None)
-                    if member_index is not None and self.NeedSafeStruct(self.structMembers[member_index]) == True:
-                        m_type = 'safe_%s' % member.type
-                if member.ispointer and 'safe_' not in m_type and self.TypeContainsObjectHandle(member.type, False) == False:
-                    # Ptr types w/o a safe_struct, for non-null case need to allocate new ptr and copy data in
-                    if m_type in ['void', 'char']:
-                        # For these exceptions just copy initial value over for now
-                        init_list += '\n    %s(in_struct->%s),' % (member.name, member.name)
-                        init_func_txt += '    %s = in_struct->%s;\n' % (member.name, member.name)
-                    else:
-                        default_init_list += '\n    %s(nullptr),' % (member.name)
-                        init_list += '\n    %s(nullptr),' % (member.name)
-                        init_func_txt += '    %s = nullptr;\n' % (member.name)
-                        if 'pNext' != member.name and 'void' not in m_type:
-                            if not member.isstaticarray and (member.len is None or '/' in member.len):
-                                construct_txt += '    if (in_struct->%s) {\n' % member.name
-                                construct_txt += '        %s = new %s(*in_struct->%s);\n' % (member.name, m_type, member.name)
-                                construct_txt += '    }\n'
-                                destruct_txt += '    if (%s)\n' % member.name
-                                destruct_txt += '        delete %s;\n' % member.name
-                            else:
-                                construct_txt += '    if (in_struct->%s) {\n' % member.name
-                                construct_txt += '        %s = new %s[in_struct->%s];\n' % (member.name, m_type, member.len)
-                                construct_txt += '        memcpy ((void *)%s, (void *)in_struct->%s, sizeof(%s)*in_struct->%s);\n' % (member.name, member.name, m_type, member.len)
-                                construct_txt += '    }\n'
-                                destruct_txt += '    if (%s)\n' % member.name
-                                destruct_txt += '        delete[] %s;\n' % member.name
-                elif member.isstaticarray or member.len is not None:
-                    if member.len is None:
-                        # Extract length of static array by grabbing val between []
-                        static_array_size = re.match(r"[^[]*\[([^]]*)\]", member.cdecl)
-                        construct_txt += '    for (uint32_t i=0; i<%s; ++i) {\n' % static_array_size.group(1)
-                        construct_txt += '        %s[i] = in_struct->%s[i];\n' % (member.name, member.name)
-                        construct_txt += '    }\n'
-                    else:
-                        # Init array ptr to NULL
-                        default_init_list += '\n    %s(nullptr),' % member.name
-                        init_list += '\n    %s(nullptr),' % member.name
-                        init_func_txt += '    %s = nullptr;\n' % member.name
-                        array_element = 'in_struct->%s[i]' % member.name
-                        if member.type in self.structNames:
-                            member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == member.type), None)
-                            if member_index is not None and self.NeedSafeStruct(self.structMembers[member_index]) == True:
-                                array_element = '%s(&in_struct->safe_%s[i])' % (member.type, member.name)
-                        construct_txt += '    if (%s && in_struct->%s) {\n' % (member.len, member.name)
-                        construct_txt += '        %s = new %s[%s];\n' % (member.name, m_type, member.len)
-                        destruct_txt += '    if (%s)\n' % member.name
-                        destruct_txt += '        delete[] %s;\n' % member.name
-                        construct_txt += '        for (uint32_t i=0; i<%s; ++i) {\n' % (member.len)
-                        if 'safe_' in m_type:
-                            construct_txt += '            %s[i].initialize(&in_struct->%s[i]);\n' % (member.name, member.name)
-                        else:
-                            construct_txt += '            %s[i] = %s;\n' % (member.name, array_element)
-                        construct_txt += '        }\n'
-                        construct_txt += '    }\n'
-                elif member.ispointer == True:
-                    construct_txt += '    if (in_struct->%s)\n' % member.name
-                    construct_txt += '        %s = new %s(in_struct->%s);\n' % (member.name, m_type, member.name)
-                    construct_txt += '    else\n'
-                    construct_txt += '        %s = NULL;\n' % member.name
-                    destruct_txt += '    if (%s)\n' % member.name
-                    destruct_txt += '        delete %s;\n' % member.name
-                elif 'safe_' in m_type:
-                    init_list += '\n    %s(&in_struct->%s),' % (member.name, member.name)
-                    init_func_txt += '    %s.initialize(&in_struct->%s);\n' % (member.name, member.name)
-                else:
-                    init_list += '\n    %s(in_struct->%s),' % (member.name, member.name)
-                    init_func_txt += '    %s = in_struct->%s;\n' % (member.name, member.name)
-            if '' != init_list:
-                init_list = init_list[:-1] # hack off final comma
-            if item.name in custom_construct_txt:
-                construct_txt = custom_construct_txt[item.name]
-            if item.name in custom_destruct_txt:
-                destruct_txt = custom_destruct_txt[item.name]
-            safe_struct_body.append("\n%s::%s(const %s* in_struct%s) :%s\n{\n%s}" % (ss_name, ss_name, item.name, self.custom_construct_params.get(item.name, ''), init_list, construct_txt))
-            if '' != default_init_list:
-                default_init_list = " :%s" % (default_init_list[:-1])
-            safe_struct_body.append("\n%s::%s()%s\n{}" % (ss_name, ss_name, default_init_list))
-            # Create slight variation of init and construct txt for copy constructor that takes a src object reference vs. struct ptr
-            copy_construct_init = init_func_txt.replace('in_struct->', 'src.')
-            copy_construct_txt = construct_txt.replace(' (in_struct->', ' (src.')     # Exclude 'if' blocks from next line
-            copy_construct_txt = copy_construct_txt.replace('(in_struct->', '(*src.') # Pass object to copy constructors
-            copy_construct_txt = copy_construct_txt.replace('in_struct->', 'src.')    # Modify remaining struct refs for src object
-            if item.name in custom_copy_txt:
-                copy_construct_txt = custom_copy_txt[item.name]
-            copy_assign_txt = '    if (&src == this) return *this;\n\n' + destruct_txt + '\n' + copy_construct_init + copy_construct_txt + '\n    return *this;'
-            safe_struct_body.append("\n%s::%s(const %s& src)\n{\n%s%s}" % (ss_name, ss_name, ss_name, copy_construct_init, copy_construct_txt)) # Copy constructor
-            safe_struct_body.append("\n%s& %s::operator=(const %s& src)\n{\n%s\n}" % (ss_name, ss_name, ss_name, copy_assign_txt)) # Copy assignment operator
-            safe_struct_body.append("\n%s::~%s()\n{\n%s}" % (ss_name, ss_name, destruct_txt))
-            safe_struct_body.append("\nvoid %s::initialize(const %s* in_struct%s)\n{\n%s%s}" % (ss_name, item.name, self.custom_construct_params.get(item.name, ''), init_func_txt, construct_txt))
-            # Copy initializer uses same txt as copy constructor but has a ptr and not a reference
-            init_copy = copy_construct_init.replace('src.', 'src->')
-            init_construct = copy_construct_txt.replace('src.', 'src->')
-            safe_struct_body.append("\nvoid %s::initialize(const %s* src)\n{\n%s%s}" % (ss_name, ss_name, init_copy, init_construct))
-            if item.ifdef_protect is not None:
-                safe_struct_body.append("#endif // %s\n" % item.ifdef_protect)
-        return "\n".join(safe_struct_body)
-    #
-    # Generate the type map
-    def GenerateTypeMapHelperHeader(self):
-        prefix = 'Lvl'
-        fprefix = 'lvl_'
-        typemap = prefix + 'TypeMap'
-        idmap = prefix + 'STypeMap'
-        type_member = 'Type'
-        id_member = 'kSType'
-        id_decl = 'static const VkStructureType '
-        generic_header = prefix + 'GenericHeader'
-        typename_func = fprefix + 'typename'
-        idname_func = fprefix + 'stype_name'
-        find_func = fprefix + 'find_in_chain'
-        init_func = fprefix + 'init_struct'
-
-        explanatory_comment = '\n'.join((
-                '// These empty generic templates are specialized for each type with sType',
-                '// members and for each sType -- providing a two way map between structure',
-                '// types and sTypes'))
-
-        empty_typemap = 'template <typename T> struct ' + typemap + ' {};'
-        typemap_format  = 'template <> struct {template}<{typename}> {{\n'
-        typemap_format += '    {id_decl}{id_member} = {id_value};\n'
-        typemap_format += '}};\n'
-
-        empty_idmap = 'template <VkStructureType id> struct ' + idmap + ' {};'
-        idmap_format = ''.join((
-            'template <> struct {template}<{id_value}> {{\n',
-            '    typedef {typename} {typedef};\n',
-            '}};\n'))
-
-        # Define the utilities (here so any renaming stays consistent), if this grows large, refactor to a fixed .h file
-        utilities_format = '\n'.join((
-            '// Header "base class" for pNext chain traversal',
-            'struct {header} {{',
-            '   VkStructureType sType;',
-            '   const {header} *pNext;',
-            '}};',
-            '',
-            '// Find an entry of the given type in the pNext chain',
-            'template <typename T> const T *{find_func}(const void *next) {{',
-            '    const {header} *current = reinterpret_cast<const {header} *>(next);',
-            '    const T *found = nullptr;',
-            '    while (current) {{',
-            '        if ({type_map}<T>::{id_member} == current->sType) {{',
-            '            found = reinterpret_cast<const T*>(current);',
-            '            current = nullptr;',
-            '        }} else {{',
-            '            current = current->pNext;',
-            '        }}',
-            '    }}',
-            '    return found;',
-            '}}',
-            '',
-            '// Init the header of an sType struct with pNext',
-            'template <typename T> T {init_func}(void *p_next) {{',
-            '    T out = {{}};',
-            '    out.sType = {type_map}<T>::kSType;',
-            '    out.pNext = p_next;',
-            '    return out;',
-            '}}',
-                        '',
-            '// Init the header of an sType struct',
-            'template <typename T> T {init_func}() {{',
-            '    T out = {{}};',
-            '    out.sType = {type_map}<T>::kSType;',
-            '    return out;',
-            '}}',
-
-            ''))
-
-        code = []
-
-        # Generate header
-        code.append('\n'.join((
-            '#pragma once',
-            '#include <vulkan/vulkan.h>\n',
-            explanatory_comment, '',
-            empty_idmap,
-            empty_typemap, '')))
-
-        # Generate the specializations for each type and stype
-        for item in self.structMembers:
-            typename = item.name
-            info = self.structTypes.get(typename)
-            if not info:
-                continue
-
-            if item.ifdef_protect is not None:
-                code.append('#ifdef %s' % item.ifdef_protect)
-
-            code.append('// Map type {} to id {}'.format(typename, info.value))
-            code.append(typemap_format.format(template=typemap, typename=typename, id_value=info.value,
-                id_decl=id_decl, id_member=id_member))
-            code.append(idmap_format.format(template=idmap, typename=typename, id_value=info.value, typedef=type_member))
-
-            if item.ifdef_protect is not None:
-                code.append('#endif // %s' % item.ifdef_protect)
-
-        # Generate utilities for all types
-        code.append('\n'.join((
-            utilities_format.format(id_member=id_member, id_map=idmap, type_map=typemap,
-                type_member=type_member, header=generic_header, typename_func=typename_func, idname_func=idname_func,
-                find_func=find_func, init_func=init_func), ''
-            )))
-
-        return "\n".join(code)
 
     #
     # Create a helper file and return it as a string
     def OutputDestFile(self):
-        if self.helper_file_type == 'enum_string_header':
-            return self.GenerateEnumStringHelperHeader()
-        elif self.helper_file_type == 'safe_struct_header':
-            return self.GenerateSafeStructHelperHeader()
-        elif self.helper_file_type == 'safe_struct_source':
-            return self.GenerateSafeStructHelperSource()
-        elif self.helper_file_type == 'object_types_header':
+        if self.helper_file_type == 'object_types_header':
             return self.GenerateObjectTypesHelperHeader()
-        elif self.helper_file_type == 'extension_helper_header':
-            return self.GenerateExtensionHelperHeader()
-        elif self.helper_file_type == 'typemap_helper_header':
-            return self.GenerateTypeMapHelperHeader()
         else:
             return 'Bad Helper File Generator Option %s' % self.helper_file_type