diff --git a/BUILD.gn b/BUILD.gn index eb9d270c679..3f7350ac0ee 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -341,8 +341,18 @@ vvl_sources = [ "layers/vulkan/generated/cmd_validation_copy_buffer_to_image_comp.h", "layers/vulkan/generated/cmd_validation_dispatch_comp.cpp", "layers/vulkan/generated/cmd_validation_dispatch_comp.h", - "layers/vulkan/generated/cmd_validation_draw_vert.cpp", - "layers/vulkan/generated/cmd_validation_draw_vert.h", + "layers/vulkan/generated/cmd_validation_count_buffer_vert.h", + "layers/vulkan/generated/cmd_validation_count_buffer_vert.cpp", + "layers/vulkan/generated/cmd_validation_first_instance_vert.h", + "layers/vulkan/generated/cmd_validation_first_instance_vert.cpp", + "layers/vulkan/generated/cmd_validation_draw_indexed_vert.h", + "layers/vulkan/generated/cmd_validation_draw_indexed_vert.cpp", + "layers/vulkan/generated/cmd_validation_draw_indexed_indirect_index_buffer_vert.h", + "layers/vulkan/generated/cmd_validation_draw_indexed_indirect_index_buffer_vert.cpp", + "layers/vulkan/generated/cmd_validation_draw_indexed_indirect_vertex_buffer_vert.h", + "layers/vulkan/generated/cmd_validation_draw_indexed_indirect_vertex_buffer_vert.cpp", + "layers/vulkan/generated/cmd_validation_draw_mesh_indirect_vert.h", + "layers/vulkan/generated/cmd_validation_draw_mesh_indirect_vert.cpp", "layers/vulkan/generated/cmd_validation_trace_rays_rgen.cpp", "layers/vulkan/generated/cmd_validation_trace_rays_rgen.h", "layers/vulkan/generated/command_validation.cpp", diff --git a/layers/CMakeLists.txt b/layers/CMakeLists.txt index 91afeb8768e..71aa4a585ac 100644 --- a/layers/CMakeLists.txt +++ b/layers/CMakeLists.txt @@ -213,8 +213,18 @@ target_sources(vvl PRIVATE ${API_TYPE}/generated/cmd_validation_copy_buffer_to_image_comp.cpp ${API_TYPE}/generated/cmd_validation_dispatch_comp.h ${API_TYPE}/generated/cmd_validation_dispatch_comp.cpp - ${API_TYPE}/generated/cmd_validation_draw_vert.h - ${API_TYPE}/generated/cmd_validation_draw_vert.cpp + ${API_TYPE}/generated/cmd_validation_count_buffer_vert.h + ${API_TYPE}/generated/cmd_validation_count_buffer_vert.cpp + ${API_TYPE}/generated/cmd_validation_first_instance_vert.h + ${API_TYPE}/generated/cmd_validation_first_instance_vert.cpp + ${API_TYPE}/generated/cmd_validation_draw_indexed_vert.h + ${API_TYPE}/generated/cmd_validation_draw_indexed_vert.cpp + ${API_TYPE}/generated/cmd_validation_draw_indexed_indirect_index_buffer_vert.h + ${API_TYPE}/generated/cmd_validation_draw_indexed_indirect_index_buffer_vert.cpp + ${API_TYPE}/generated/cmd_validation_draw_indexed_indirect_vertex_buffer_vert.h + ${API_TYPE}/generated/cmd_validation_draw_indexed_indirect_vertex_buffer_vert.cpp + ${API_TYPE}/generated/cmd_validation_draw_mesh_indirect_vert.h + ${API_TYPE}/generated/cmd_validation_draw_mesh_indirect_vert.cpp ${API_TYPE}/generated/cmd_validation_trace_rays_rgen.h ${API_TYPE}/generated/cmd_validation_trace_rays_rgen.cpp gpu/core/gpu_settings.h diff --git a/layers/VkLayer_khronos_validation.json.in b/layers/VkLayer_khronos_validation.json.in index 45cb263ad1f..c1f61a418f9 100644 --- a/layers/VkLayer_khronos_validation.json.in +++ b/layers/VkLayer_khronos_validation.json.in @@ -1142,6 +1142,26 @@ } ] } + }, + { + "key": "gpuav_index_buffers", + "label": "Index buffers", + "type": "BOOL", + "default": true, + "description": "Validate that indexed draws do not fetch indices outside of the bounds of the index buffer. Also validates that those indices are not out of the bounds of the fetched vertex buffers.", + "platforms": [ + "WINDOWS", + "LINUX" + ], + "dependence": { + "mode": "ALL", + "settings": [ + { + "key": "gpuav_buffers_validation", + "value": true + } + ] + } } ] }, diff --git a/layers/gpu/cmd_validation/gpuav_cmd_validation_common.cpp b/layers/gpu/cmd_validation/gpuav_cmd_validation_common.cpp index fdd536911c9..8c25209f0c9 100644 --- a/layers/gpu/cmd_validation/gpuav_cmd_validation_common.cpp +++ b/layers/gpu/cmd_validation/gpuav_cmd_validation_common.cpp @@ -22,12 +22,13 @@ #include "gpu/shaders/gpu_shaders_constants.h" #include "state_tracker/descriptor_sets.h" +#include "state_tracker/render_pass_state.h" #include "state_tracker/shader_object_state.h" namespace gpuav { -void BindValidationCmdsCommonDescSet(Validator &gpuav, CommandBuffer &cb_state, VkPipelineBindPoint bind_point, - VkPipelineLayout pipeline_layout, uint32_t cmd_index, uint32_t error_logger_index) { +void BindErrorLoggingDescriptorSet(Validator &gpuav, CommandBuffer &cb_state, VkPipelineBindPoint bind_point, + VkPipelineLayout pipeline_layout, uint32_t cmd_index, uint32_t error_logger_index) { assert(cmd_index < cst::indices_count); assert(error_logger_index < cst::indices_count); std::array dynamic_offsets = { @@ -38,8 +39,7 @@ void BindValidationCmdsCommonDescSet(Validator &gpuav, CommandBuffer &cb_state, dynamic_offsets.data()); } -void RestorablePipelineState::Create(vvl::CommandBuffer &cb_state, VkPipelineBindPoint bind_point) { - cmd_buffer_ = cb_state.VkHandle(); +void RestorablePipelineState::Create(CommandBuffer &cb_state, VkPipelineBindPoint bind_point) { pipeline_bind_point_ = bind_point; const auto lv_bind_point = ConvertToLvlBindPoint(bind_point); @@ -78,11 +78,29 @@ void RestorablePipelineState::Create(vvl::CommandBuffer &cb_state, VkPipelineBin if (last_bound.push_descriptor_set) { push_descriptor_set_writes_ = last_bound.push_descriptor_set->GetWrites(); } + + // Do not handle cb_state.activeRenderPass->use_dynamic_rendering_inherited for now + if (bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS && cb_state.activeRenderPass->use_dynamic_rendering) { + rendering_info_ = &cb_state.activeRenderPass->dynamic_rendering_begin_rendering_info; + DispatchCmdEndRendering(cb_state.VkHandle()); + + VkRenderingInfo rendering_info = vku::InitStructHelper(); + rendering_info.renderArea = {{0, 0}, {1, 1}}; + rendering_info.layerCount = 1; + rendering_info.viewMask = 0; + rendering_info.colorAttachmentCount = 0; + DispatchCmdBeginRendering(cb_state.VkHandle(), &rendering_info); + } } void RestorablePipelineState::Restore() const { + if (rendering_info_) { + DispatchCmdEndRendering(cb_state_.VkHandle()); + DispatchCmdBeginRendering(cb_state_.VkHandle(), rendering_info_->ptr()); + } + if (pipeline_ != VK_NULL_HANDLE) { - DispatchCmdBindPipeline(cmd_buffer_, pipeline_bind_point_, pipeline_); + DispatchCmdBindPipeline(cb_state_.VkHandle(), pipeline_bind_point_, pipeline_); } if (!shader_objects_.empty()) { std::vector stages; @@ -91,29 +109,34 @@ void RestorablePipelineState::Restore() const { stages.emplace_back(shader_obj->create_info.stage); shaders.emplace_back(shader_obj->VkHandle()); } - DispatchCmdBindShadersEXT(cmd_buffer_, static_cast(shader_objects_.size()), stages.data(), shaders.data()); + DispatchCmdBindShadersEXT(cb_state_.VkHandle(), static_cast(shader_objects_.size()), stages.data(), + shaders.data()); } for (std::size_t i = 0; i < descriptor_sets_.size(); i++) { VkDescriptorSet descriptor_set = descriptor_sets_[i].first; if (descriptor_set != VK_NULL_HANDLE) { - DispatchCmdBindDescriptorSets(cmd_buffer_, pipeline_bind_point_, desc_set_pipeline_layout_, descriptor_sets_[i].second, - 1, &descriptor_set, static_cast(dynamic_offsets_[i].size()), - dynamic_offsets_[i].data()); + DispatchCmdBindDescriptorSets(cb_state_.VkHandle(), pipeline_bind_point_, desc_set_pipeline_layout_, + descriptor_sets_[i].second, 1, &descriptor_set, + static_cast(dynamic_offsets_[i].size()), dynamic_offsets_[i].data()); } } if (!push_descriptor_set_writes_.empty()) { - DispatchCmdPushDescriptorSetKHR(cmd_buffer_, pipeline_bind_point_, desc_set_pipeline_layout_, push_descriptor_set_index_, - static_cast(push_descriptor_set_writes_.size()), + DispatchCmdPushDescriptorSetKHR(cb_state_.VkHandle(), pipeline_bind_point_, desc_set_pipeline_layout_, + push_descriptor_set_index_, static_cast(push_descriptor_set_writes_.size()), reinterpret_cast(push_descriptor_set_writes_.data())); } for (const auto &push_constant_range : push_constants_data_) { - DispatchCmdPushConstants(cmd_buffer_, push_constant_range.layout, push_constant_range.stage_flags, + DispatchCmdPushConstants(cb_state_.VkHandle(), push_constant_range.layout, push_constant_range.stage_flags, push_constant_range.offset, static_cast(push_constant_range.values.size()), push_constant_range.values.data()); } + + if (pipeline_bind_point_ == VK_PIPELINE_BIND_POINT_GRAPHICS) { + cb_state_.RestoreDynamicStates(gpuav_); + } } } // namespace gpuav diff --git a/layers/gpu/cmd_validation/gpuav_cmd_validation_common.h b/layers/gpu/cmd_validation/gpuav_cmd_validation_common.h index a3a85058131..a0df677707f 100644 --- a/layers/gpu/cmd_validation/gpuav_cmd_validation_common.h +++ b/layers/gpu/cmd_validation/gpuav_cmd_validation_common.h @@ -27,14 +27,19 @@ class Validator; class RestorablePipelineState { public: - RestorablePipelineState(vvl::CommandBuffer& cb_state, VkPipelineBindPoint bind_point) { Create(cb_state, bind_point); } + RestorablePipelineState(const Validator& gpuav, CommandBuffer& cb_state, VkPipelineBindPoint bind_point) + : gpuav_(gpuav), cb_state_(cb_state) { + Create(cb_state, bind_point); + } ~RestorablePipelineState() { Restore(); } private: - void Create(vvl::CommandBuffer& cb_state, VkPipelineBindPoint bind_point); + void Create(CommandBuffer& cb_state, VkPipelineBindPoint bind_point); void Restore() const; - VkCommandBuffer cmd_buffer_; + const Validator& gpuav_; + CommandBuffer& cb_state_; + const vku::safe_VkRenderingInfo* rendering_info_ = nullptr; VkPipelineBindPoint pipeline_bind_point_ = VK_PIPELINE_BIND_POINT_MAX_ENUM; VkPipeline pipeline_ = VK_NULL_HANDLE; VkPipelineLayout desc_set_pipeline_layout_ = VK_NULL_HANDLE; @@ -46,7 +51,7 @@ class RestorablePipelineState { std::vector shader_objects_; }; -void BindValidationCmdsCommonDescSet(Validator& gpuav, CommandBuffer& cb_state, VkPipelineBindPoint bind_point, - VkPipelineLayout pipeline_layout, uint32_t cmd_index, uint32_t error_logger_index); +void BindErrorLoggingDescriptorSet(Validator& gpuav, CommandBuffer& cb_state, VkPipelineBindPoint bind_point, + VkPipelineLayout pipeline_layout, uint32_t cmd_index, uint32_t error_logger_index); } // namespace gpuav diff --git a/layers/gpu/cmd_validation/gpuav_copy_buffer_to_image.cpp b/layers/gpu/cmd_validation/gpuav_copy_buffer_to_image.cpp index 74ee3cbbd0c..f77f85d1b1f 100644 --- a/layers/gpu/cmd_validation/gpuav_copy_buffer_to_image.cpp +++ b/layers/gpu/cmd_validation/gpuav_copy_buffer_to_image.cpp @@ -307,14 +307,13 @@ void InsertCopyBufferToImageValidation(Validator &gpuav, const Location &loc, Co DispatchUpdateDescriptorSets(gpuav.device, static_cast(desc_writes.size()), desc_writes.data(), 0, nullptr); } // Save current graphics pipeline state - RestorablePipelineState restorable_state(cb_state, VK_PIPELINE_BIND_POINT_COMPUTE); + RestorablePipelineState restorable_state(gpuav, cb_state, VK_PIPELINE_BIND_POINT_COMPUTE); // Insert diagnostic dispatch DispatchCmdBindPipeline(cb_state.VkHandle(), VK_PIPELINE_BIND_POINT_COMPUTE, shared_copy_validation_resources.pipeline); - BindValidationCmdsCommonDescSet(gpuav, cb_state, VK_PIPELINE_BIND_POINT_COMPUTE, - shared_copy_validation_resources.pipeline_layout, 0, - static_cast(cb_state.per_command_error_loggers.size())); + BindErrorLoggingDescriptorSet(gpuav, cb_state, VK_PIPELINE_BIND_POINT_COMPUTE, shared_copy_validation_resources.pipeline_layout, + 0, static_cast(cb_state.per_command_error_loggers.size())); DispatchCmdBindDescriptorSets(cb_state.VkHandle(), VK_PIPELINE_BIND_POINT_COMPUTE, shared_copy_validation_resources.pipeline_layout, glsl::kDiagPerCmdDescriptorSet, 1, &validation_desc_set, 0, nullptr); diff --git a/layers/gpu/cmd_validation/gpuav_dispatch.cpp b/layers/gpu/cmd_validation/gpuav_dispatch.cpp index fd08dc79d2a..03231f27a59 100644 --- a/layers/gpu/cmd_validation/gpuav_dispatch.cpp +++ b/layers/gpu/cmd_validation/gpuav_dispatch.cpp @@ -189,7 +189,7 @@ void InsertIndirectDispatchValidation(Validator &gpuav, const Location &loc, Com DispatchUpdateDescriptorSets(gpuav.device, 1, &desc_write, 0, nullptr); // Save current graphics pipeline state - RestorablePipelineState restorable_state(cb_state, VK_PIPELINE_BIND_POINT_COMPUTE); + RestorablePipelineState restorable_state(gpuav, cb_state, VK_PIPELINE_BIND_POINT_COMPUTE); // Insert diagnostic dispatch if (use_shader_objects) { @@ -205,8 +205,8 @@ void InsertIndirectDispatchValidation(Validator &gpuav, const Location &loc, Com push_constants[3] = static_cast((indirect_offset / sizeof(uint32_t))); DispatchCmdPushConstants(cb_state.VkHandle(), shared_dispatch_resources.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(push_constants), push_constants); - BindValidationCmdsCommonDescSet(gpuav, cb_state, VK_PIPELINE_BIND_POINT_COMPUTE, shared_dispatch_resources.pipeline_layout, - cb_state.compute_index, static_cast(cb_state.per_command_error_loggers.size())); + BindErrorLoggingDescriptorSet(gpuav, cb_state, VK_PIPELINE_BIND_POINT_COMPUTE, shared_dispatch_resources.pipeline_layout, + cb_state.compute_index, static_cast(cb_state.per_command_error_loggers.size())); DispatchCmdBindDescriptorSets(cb_state.VkHandle(), VK_PIPELINE_BIND_POINT_COMPUTE, shared_dispatch_resources.pipeline_layout, glsl::kDiagPerCmdDescriptorSet, 1, &indirect_buffer_desc_set, 0, nullptr); DispatchCmdDispatch(cb_state.VkHandle(), 1, 1, 1); diff --git a/layers/gpu/cmd_validation/gpuav_draw.cpp b/layers/gpu/cmd_validation/gpuav_draw.cpp index e197fd12a62..e5b91784453 100644 --- a/layers/gpu/cmd_validation/gpuav_draw.cpp +++ b/layers/gpu/cmd_validation/gpuav_draw.cpp @@ -15,453 +15,1118 @@ * limitations under the License. */ +#include "gpu/cmd_validation/gpuav_draw.h" + #include "gpu/core/gpuav.h" #include "gpu/cmd_validation/gpuav_cmd_validation_common.h" #include "gpu/error_message/gpuav_vuids.h" +#include "gpu/resources/gpu_resources.h" #include "gpu/resources/gpuav_subclasses.h" +#include "state_tracker/cmd_buffer_state.h" #include "state_tracker/render_pass_state.h" #include "gpu/shaders/gpu_error_header.h" #include "gpu/shaders/gpu_shaders_constants.h" -#include "generated/cmd_validation_draw_vert.h" - -// See gpu/shaders/cmd_validation/draw.vert -constexpr uint32_t kPushConstantDWords = 11u; +#include "gpu/shaders/cmd_validation/draw_push_data.h" +#include "generated/cmd_validation_draw_mesh_indirect_vert.h" +#include "generated/cmd_validation_first_instance_vert.h" +#include "generated/cmd_validation_count_buffer_vert.h" +#include "generated/cmd_validation_draw_indexed_vert.h" +#include "generated/cmd_validation_draw_indexed_indirect_index_buffer_vert.h" +#include "generated/cmd_validation_draw_indexed_indirect_vertex_buffer_vert.h" namespace gpuav { +namespace draw { -struct SharedDrawValidationResources final { - VkShaderModule shader_module = VK_NULL_HANDLE; - VkDescriptorSetLayout ds_layout = VK_NULL_HANDLE; - VkPipelineLayout pipeline_layout = VK_NULL_HANDLE; - VkShaderEXT shader_object = VK_NULL_HANDLE; - vvl::concurrent_unordered_map renderpass_to_pipeline; - VkDevice device = VK_NULL_HANDLE; - - SharedDrawValidationResources(Validator &gpuav, VkDescriptorSetLayout error_output_desc_set_layout, bool use_shader_objects, - const Location &loc) - : device(gpuav.device) { - VkResult result = VK_SUCCESS; - - std::vector bindings = { - {0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT, nullptr}, // count buffer - {1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT, nullptr}, // draw buffer - }; - - VkDescriptorSetLayoutCreateInfo ds_layout_ci = vku::InitStructHelper(); - ds_layout_ci.bindingCount = static_cast(bindings.size()); - ds_layout_ci.pBindings = bindings.data(); - result = DispatchCreateDescriptorSetLayout(device, &ds_layout_ci, nullptr, &ds_layout); - if (result != VK_SUCCESS) { - gpuav.InternalError(device, loc, "Unable to create descriptor set layout for SharedDrawValidationResources."); - return; - } - - VkPushConstantRange push_constant_range = {}; - push_constant_range.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; - push_constant_range.offset = 0; - push_constant_range.size = kPushConstantDWords * sizeof(uint32_t); +struct SharedDrawValidationResources { + VmaAllocator vma_allocator; + gpu::DeviceMemoryBlock dummy_buffer; // Used to fill unused buffer bindings in validation pipelines + bool valid = false; - std::array set_layouts = {{error_output_desc_set_layout, ds_layout}}; - VkPipelineLayoutCreateInfo pipeline_layout_ci = vku::InitStructHelper(); - pipeline_layout_ci.pushConstantRangeCount = 1; - pipeline_layout_ci.pPushConstantRanges = &push_constant_range; - pipeline_layout_ci.setLayoutCount = static_cast(set_layouts.size()); - pipeline_layout_ci.pSetLayouts = set_layouts.data(); - result = DispatchCreatePipelineLayout(device, &pipeline_layout_ci, nullptr, &pipeline_layout); + SharedDrawValidationResources(Validator &gpuav, const Location &loc) : vma_allocator(gpuav.vma_allocator_) { + VkBufferCreateInfo dummy_buffer_info = vku::InitStructHelper(); + dummy_buffer_info.size = 64;// whatever + dummy_buffer_info.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; + VmaAllocationCreateInfo alloc_info = {}; + dummy_buffer_info.size = dummy_buffer_info.size; + VkResult result = vmaCreateBuffer(gpuav.vma_allocator_, &dummy_buffer_info, &alloc_info, &dummy_buffer.buffer, + &dummy_buffer.allocation, nullptr); if (result != VK_SUCCESS) { - gpuav.InternalError(device, loc, "Unable to create pipeline layout for SharedDrawValidationResources."); + gpuav.InternalError(gpuav.device, loc, "Unable to allocate device memory for dummy buffer.", true); return; } - if (use_shader_objects) { - VkShaderCreateInfoEXT shader_ci = vku::InitStructHelper(); - shader_ci.stage = VK_SHADER_STAGE_VERTEX_BIT; - shader_ci.codeType = VK_SHADER_CODE_TYPE_SPIRV_EXT; - shader_ci.codeSize = cmd_validation_draw_vert_size * sizeof(uint32_t); - shader_ci.pCode = cmd_validation_draw_vert; - shader_ci.pName = "main"; - shader_ci.setLayoutCount = static_cast(set_layouts.size()); - shader_ci.pSetLayouts = set_layouts.data(); - shader_ci.pushConstantRangeCount = 1; - shader_ci.pPushConstantRanges = &push_constant_range; - result = DispatchCreateShadersEXT(device, 1u, &shader_ci, nullptr, &shader_object); - if (result != VK_SUCCESS) { - gpuav.InternalError(device, loc, "Unable to create shader object."); - return; - } - } else { - VkShaderModuleCreateInfo shader_module_ci = vku::InitStructHelper(); - shader_module_ci.codeSize = cmd_validation_draw_vert_size * sizeof(uint32_t); - shader_module_ci.pCode = cmd_validation_draw_vert; - result = DispatchCreateShaderModule(device, &shader_module_ci, nullptr, &shader_module); - if (result != VK_SUCCESS) { - gpuav.InternalError(device, loc, "Unable to create shader module."); - return; - } - } + valid = true; } - ~SharedDrawValidationResources() { - if (shader_module != VK_NULL_HANDLE) { - DispatchDestroyShaderModule(device, shader_module, nullptr); - shader_module = VK_NULL_HANDLE; - } - if (ds_layout != VK_NULL_HANDLE) { - DispatchDestroyDescriptorSetLayout(device, ds_layout, nullptr); - ds_layout = VK_NULL_HANDLE; - } - if (pipeline_layout != VK_NULL_HANDLE) { - DispatchDestroyPipelineLayout(device, pipeline_layout, nullptr); - pipeline_layout = VK_NULL_HANDLE; - } - auto to_destroy = renderpass_to_pipeline.snapshot(); - for (auto &entry : to_destroy) { - DispatchDestroyPipeline(device, entry.second, nullptr); - renderpass_to_pipeline.erase(entry.first); - } - if (shader_object != VK_NULL_HANDLE) { - DispatchDestroyShaderEXT(device, shader_object, nullptr); - shader_object = VK_NULL_HANDLE; - } - } - - bool IsValid() const { return shader_module != VK_NULL_HANDLE || shader_object != VK_NULL_HANDLE; } + ~SharedDrawValidationResources() { dummy_buffer.Destroy(vma_allocator); } }; -// This function will add the returned VkPipeline handle to another object incharge of destroying it. Caller does NOT have to -// destroy it -static VkPipeline GetDrawValidationPipeline(Validator &gpuav, SharedDrawValidationResources &shared_draw_resources, +// This function will add the returned VkPipeline handle to another object in charge of destroying it. Caller must not destroy it. +static VkPipeline GetDrawValidationPipeline(Validator &gpuav, + vvl::concurrent_unordered_map &render_passes_to_pipeline, + VkPipelineLayout pipeline_layout, VkShaderModule shader_module, VkRenderPass render_pass, const Location &loc) { - VkPipeline validation_pipeline = VK_NULL_HANDLE; // NOTE: for dynamic rendering, render_pass will be VK_NULL_HANDLE but we'll use that as a map // key anyways; - if (auto pipeline_entry = shared_draw_resources.renderpass_to_pipeline.find(render_pass); - pipeline_entry != shared_draw_resources.renderpass_to_pipeline.end()) { - validation_pipeline = pipeline_entry->second; - } - if (validation_pipeline != VK_NULL_HANDLE) { + if (auto pipeline_entry = render_passes_to_pipeline.find(render_pass); pipeline_entry != render_passes_to_pipeline.end()) { + VkPipeline validation_pipeline = pipeline_entry->second; + assert(validation_pipeline != VK_NULL_HANDLE); return validation_pipeline; } + + // Create all validation pipeline for the input render_pass + VkPipeline pipeline = VK_NULL_HANDLE; VkPipelineShaderStageCreateInfo pipeline_stage_ci = vku::InitStructHelper(); pipeline_stage_ci.stage = VK_SHADER_STAGE_VERTEX_BIT; - pipeline_stage_ci.module = shared_draw_resources.shader_module; + pipeline_stage_ci.module = shader_module; pipeline_stage_ci.pName = "main"; VkGraphicsPipelineCreateInfo pipeline_ci = vku::InitStructHelper(); + // As of writing, adding a VkPipelineRenderingCreateInfoKHR is not strictly needed, + // if dynamic rendering is used a default empty VkPipelineRenderingCreateInfoKHR + // is assumed. Might have to change in the future. + // VkPipelineRenderingCreateInfoKHR pipeline_rendering_ci = vku::InitStructHelper(); + // if (using_dynamic_rendering) pipeline_ci.pNext = &pipeline_rendering_ci; + VkPipelineVertexInputStateCreateInfo vertex_input_state = vku::InitStructHelper(); VkPipelineInputAssemblyStateCreateInfo input_assembly_state = vku::InitStructHelper(); - input_assembly_state.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + input_assembly_state.topology = VK_PRIMITIVE_TOPOLOGY_POINT_LIST; VkPipelineRasterizationStateCreateInfo rasterization_state = vku::InitStructHelper(); + rasterization_state.lineWidth = 1.0; rasterization_state.rasterizerDiscardEnable = VK_TRUE; VkPipelineColorBlendStateCreateInfo color_blend_state = vku::InitStructHelper(); pipeline_ci.pVertexInputState = &vertex_input_state; pipeline_ci.pInputAssemblyState = &input_assembly_state; + pipeline_ci.pTessellationState = + nullptr; // If not null, need to update gpuav::CommandBuffer::RestoreDynamicStates with corresponding dynamic states + pipeline_ci.pViewportState = + nullptr; // If not null, need to update gpuav::CommandBuffer::RestoreDynamicStates with corresponding dynamic states pipeline_ci.pRasterizationState = &rasterization_state; + pipeline_ci.pMultisampleState = + nullptr; // If not null, need to update gpuav::CommandBuffer::RestoreDynamicStates with corresponding dynamic states + pipeline_ci.pDepthStencilState = + nullptr; // If not null, need to update gpuav::CommandBuffer::RestoreDynamicStates with corresponding dynamic states pipeline_ci.pColorBlendState = &color_blend_state; pipeline_ci.renderPass = render_pass; - pipeline_ci.layout = shared_draw_resources.pipeline_layout; + pipeline_ci.layout = pipeline_layout; pipeline_ci.stageCount = 1; pipeline_ci.pStages = &pipeline_stage_ci; - VkResult result = DispatchCreateGraphicsPipelines(gpuav.device, VK_NULL_HANDLE, 1, &pipeline_ci, nullptr, &validation_pipeline); + VkResult result = DispatchCreateGraphicsPipelines(gpuav.device, VK_NULL_HANDLE, 1, &pipeline_ci, nullptr, &pipeline); if (result != VK_SUCCESS) { gpuav.InternalError(gpuav.device, loc, "Unable to create graphics pipeline."); return VK_NULL_HANDLE; } - shared_draw_resources.renderpass_to_pipeline.insert(render_pass, validation_pipeline); - return validation_pipeline; + render_passes_to_pipeline.insert(render_pass, pipeline); + return pipeline; } -void DestroyRenderPassMappedResources(Validator &gpuav, VkRenderPass render_pass) { - auto *shared_draw_resources = gpuav.shared_resources_manager.TryGet(); +struct ValidationPipeline { + VkDevice device = VK_NULL_HANDLE; + VkDescriptorSetLayout specific_desc_set_layout = VK_NULL_HANDLE; + VkPipelineLayout pipeline_layout = VK_NULL_HANDLE; + VkShaderModule shader_module = VK_NULL_HANDLE; + bool valid = false; - if (!shared_draw_resources || !shared_draw_resources->IsValid()) { - return; + void Init(Validator &gpuav, const Location &loc, VkDescriptorSetLayout error_output_desc_set_layout, + const std::vector &specific_bindings, const VkPushConstantRange &push_constant_range, + size_t spirv_dwords_count, const uint32_t *spirv) { + device = gpuav.device; + VkDescriptorSetLayoutCreateInfo ds_layout_ci = vku::InitStructHelper(); + + ds_layout_ci.bindingCount = static_cast(specific_bindings.size()); + ds_layout_ci.pBindings = specific_bindings.data(); + VkResult result = DispatchCreateDescriptorSetLayout(device, &ds_layout_ci, nullptr, &specific_desc_set_layout); + if (result != VK_SUCCESS) { + gpuav.InternalError(device, loc, "Unable to create descriptor set layout for SharedDrawValidationResources."); + return; + } + + std::array set_layouts = {{error_output_desc_set_layout, specific_desc_set_layout}}; + VkPipelineLayoutCreateInfo pipeline_layout_ci = vku::InitStructHelper(); + if (push_constant_range.size > 0) { + pipeline_layout_ci.pushConstantRangeCount = 1; + pipeline_layout_ci.pPushConstantRanges = &push_constant_range; + } + pipeline_layout_ci.setLayoutCount = static_cast(set_layouts.size()); + pipeline_layout_ci.pSetLayouts = set_layouts.data(); + result = DispatchCreatePipelineLayout(device, &pipeline_layout_ci, nullptr, &pipeline_layout); + if (result != VK_SUCCESS) { + gpuav.InternalError(device, loc, "Unable to create pipeline layout for SharedDrawValidationResources."); + return; + } + + VkShaderModuleCreateInfo shader_module_ci = vku::InitStructHelper(); + shader_module_ci.codeSize = spirv_dwords_count * sizeof(uint32_t); + shader_module_ci.pCode = spirv; + result = DispatchCreateShaderModule(device, &shader_module_ci, nullptr, &shader_module); + if (result != VK_SUCCESS) { + gpuav.InternalError(device, loc, "Unable to create shader module."); + return; + } + + valid = true; } - auto pipeline = shared_draw_resources->renderpass_to_pipeline.pop(render_pass); - if (pipeline != shared_draw_resources->renderpass_to_pipeline.end()) { - DispatchDestroyPipeline(gpuav.device, pipeline->second, nullptr); + ~ValidationPipeline() { + if (shader_module != VK_NULL_HANDLE) { + DispatchDestroyShaderModule(device, shader_module, nullptr); + } + + if (specific_desc_set_layout != VK_NULL_HANDLE) { + DispatchDestroyDescriptorSetLayout(device, specific_desc_set_layout, nullptr); + } + + if (pipeline_layout != VK_NULL_HANDLE) { + DispatchDestroyPipelineLayout(device, pipeline_layout, nullptr); + } + } +}; + +template +struct GraphicsValidationPipeline : ValidationPipeline { + // Why a concurrent map? + vvl::concurrent_unordered_map render_passes_to_pipeline; + + GraphicsValidationPipeline(Validator &gpuav, const Location &loc, VkDescriptorSetLayout error_output_desc_set_layout) { + std::vector specific_bindings = ShaderResources::GetDescriptorSetLayoutBindings(); + + VkPushConstantRange push_constant_range = {}; + push_constant_range.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; + push_constant_range.offset = 0; + push_constant_range.size = sizeof(ShaderResources::push_constants); // 0 size is ok here + + Init(gpuav, loc, error_output_desc_set_layout, specific_bindings, push_constant_range, + ShaderResources::GetSpirvDwordsCount(), ShaderResources::GetSpirv()); + } + + ~GraphicsValidationPipeline() { + auto to_destroy = render_passes_to_pipeline.snapshot(); + for (auto &entry : to_destroy) { + DispatchDestroyPipeline(device, entry.second, nullptr); + // render_passes_to_pipeline.erase(entry.first); + } } -} -void InsertIndirectDrawValidation(Validator &gpuav, const Location &loc, CommandBuffer &cb_state, VkBuffer indirect_buffer, - VkDeviceSize indirect_offset, uint32_t draw_count, VkBuffer count_buffer, - VkDeviceSize count_buffer_offset, uint32_t stride) { + void BindShaderResources(Validator &gpuav, CommandBuffer &cb_state, ShaderResources &shader_resources) { + // Error logging resources + BindErrorLoggingDescriptorSet(gpuav, cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, cb_state.draw_index, + uint32_t(cb_state.per_command_error_loggers.size())); + // Specific resources + VkDescriptorSet desc_set = cb_state.gpu_resources_manager.GetManagedDescriptorSet(specific_desc_set_layout); + std::vector desc_writes = shader_resources.GetDescriptorWrites(desc_set); + DispatchUpdateDescriptorSets(gpuav.device, uint32_t(desc_writes.size()), desc_writes.data(), 0, nullptr); + + DispatchCmdPushConstants(cb_state.VkHandle(), pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 0, + sizeof(shader_resources.push_constants), &shader_resources.push_constants); + + DispatchCmdBindDescriptorSets(cb_state.VkHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, + shader_resources.desc_set_id, 1, &desc_set, 0, nullptr); + } +}; + +struct FirstInstanceValidationShader { + static size_t GetSpirvDwordsCount() { return cmd_validation_first_instance_vert_size; } + static const uint32_t *GetSpirv() { return cmd_validation_first_instance_vert; } + + static const uint32_t desc_set_id = gpuav::glsl::kDiagPerCmdDescriptorSet; + + glsl::FirstInstancePushData push_constants{}; + gpu::BoundStorageBuffer draw_buffer_binding = {gpuav::glsl::kPreDrawBinding_IndirectBuffer}; + gpu::BoundStorageBuffer count_buffer_binding = {gpuav::glsl::kPreDrawBinding_CountBuffer}; + + static std::vector GetDescriptorSetLayoutBindings() { + std::vector bindings = { + {gpuav::glsl::kPreDrawBinding_IndirectBuffer, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT, + nullptr}, // indirect buffer + {gpuav::glsl::kPreDrawBinding_CountBuffer, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT, + nullptr}, // count buffer + }; + + return bindings; + } + + std::vector GetDescriptorWrites(VkDescriptorSet desc_set) { + std::vector desc_writes(2); + + desc_writes[0] = vku::InitStructHelper(); + desc_writes[0].dstSet = desc_set; + desc_writes[0].dstBinding = draw_buffer_binding.binding; + desc_writes[0].dstArrayElement = 0; + desc_writes[0].descriptorCount = 1; + desc_writes[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + desc_writes[0].pBufferInfo = &draw_buffer_binding.info; + + desc_writes[1] = vku::InitStructHelper(); + desc_writes[1].dstSet = desc_set; + desc_writes[1].dstBinding = count_buffer_binding.binding; + desc_writes[1].dstArrayElement = 0; + desc_writes[1].descriptorCount = 1; + desc_writes[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + desc_writes[1].pBufferInfo = &count_buffer_binding.info; + + return desc_writes; + } +}; + +void FirstInstance(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, VkBuffer draw_buffer, + VkDeviceSize draw_buffer_offset, uint32_t draw_cmds_byte_stride, vvl::Struct draw_indirect_struct_name, + uint32_t first_instance_member_pos, uint32_t draw_count, VkBuffer count_buffer, VkDeviceSize count_buffer_offset, + const char *vuid) { if (!gpuav.gpuav_settings.validate_indirect_draws_buffers) { return; } - const auto lv_bind_point = ConvertToLvlBindPoint(VK_PIPELINE_BIND_POINT_GRAPHICS); - auto const &last_bound = cb_state.lastBound[lv_bind_point]; - const auto *pipeline_state = last_bound.pipeline_state; - const bool use_shader_objects = pipeline_state == nullptr; + if (gpuav.enabled_features.drawIndirectFirstInstance) return; - auto &shared_draw_resources = gpuav.shared_resources_manager.Get( - gpuav, cb_state.GetValidationCmdCommonDescriptorSetLayout(), use_shader_objects, loc); + if (cb_state.activeRenderPass->use_dynamic_rendering_inherited) { + // Unhandled for now + return; + } + + RestorablePipelineState restorable_state(gpuav, cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS); - assert(shared_draw_resources.IsValid()); - if (!shared_draw_resources.IsValid()) { + auto &shared_draw_validation_resources = gpuav.shared_resources_manager.Get(gpuav, loc); + if (!shared_draw_validation_resources.valid) return; + auto &validation_pipeline = gpuav.shared_resources_manager.Get>( + gpuav, loc, cb_state.GetValidationCmdCommonDescriptorSetLayout()); + if (!validation_pipeline.valid) return; + + auto draw_buffer_state = gpuav.Get(draw_buffer); + if (!draw_buffer_state) { + gpuav.InternalError(LogObjectList(cb_state.VkHandle(), draw_buffer), loc, "buffer must be a valid VkBuffer handle"); return; } - VkPipeline validation_pipeline = VK_NULL_HANDLE; - if (!use_shader_objects) { - validation_pipeline = - GetDrawValidationPipeline(gpuav, shared_draw_resources, cb_state.activeRenderPass.get()->VkHandle(), loc); - if (validation_pipeline == VK_NULL_HANDLE) { + // Setup shader resources + // --- + { + FirstInstanceValidationShader shader_resources; + shader_resources.push_constants.draw_cmds_stride_dwords = draw_cmds_byte_stride / sizeof(uint32_t); + shader_resources.push_constants.first_instance_member_pos = first_instance_member_pos; + + shader_resources.draw_buffer_binding.info = {draw_buffer, draw_buffer_offset, VK_WHOLE_SIZE}; + if (count_buffer) { + shader_resources.push_constants.flags |= gpuav::glsl::kFirstInstanceFlags_DrawCountFromBuffer; + shader_resources.count_buffer_binding.info = {count_buffer, count_buffer_offset, sizeof(uint32_t)}; + } else { + shader_resources.count_buffer_binding.info = {shared_draw_validation_resources.dummy_buffer.buffer, 0, VK_WHOLE_SIZE}; + } + + validation_pipeline.BindShaderResources(gpuav, cb_state, shader_resources); + } + + // Setup validation pipeline + // --- + { + VkPipeline pipeline_handle = + GetDrawValidationPipeline(gpuav, validation_pipeline.render_passes_to_pipeline, validation_pipeline.pipeline_layout, + validation_pipeline.shader_module, cb_state.activeRenderPass.get()->VkHandle(), loc); + if (pipeline_handle == VK_NULL_HANDLE) { gpuav.InternalError(cb_state.VkHandle(), loc, "Could not find or create a pipeline."); return; } + + DispatchCmdBindPipeline(cb_state.VkHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_handle); + + uint32_t max_held_draw_cmds = 0; + if (draw_buffer_state->create_info.size > draw_buffer_offset) { + max_held_draw_cmds = + static_cast((draw_buffer_state->create_info.size - draw_buffer_offset) / draw_cmds_byte_stride); + } + draw_count = std::min(draw_count, max_held_draw_cmds); + DispatchCmdDraw(cb_state.VkHandle(), draw_count, 1, 0, 0); + } + + // Register error logger + // --- + CommandBuffer::ErrorLoggerFunc error_logger = + [loc, vuid, draw_indirect_struct_name](Validator &gpuav, const uint32_t *error_record, const LogObjectList &objlist) { + bool skip = false; + + using namespace glsl; + + if (error_record[kHeaderErrorGroupOffset] != kErrorGroupGpuPreDraw) { + assert(false); + return skip; + } + + assert(error_record[kHeaderErrorSubCodeOffset] == kErrorSubCodePreDrawFirstInstance); + + const uint32_t index = error_record[kPreActionParamOffset_0]; + const uint32_t invalid_first_instance = error_record[kPreActionParamOffset_1]; + skip |= gpuav.LogError( + vuid, objlist, loc, + "The drawIndirectFirstInstance feature is not enabled, but the firstInstance member of the %s structure at " + "index %" PRIu32 " is %" PRIu32 ".", + vvl::String(draw_indirect_struct_name), index, invalid_first_instance); + + return skip; + }; + + cb_state.per_command_error_loggers.emplace_back(std::move(error_logger)); +} + +template <> +void FirstInstance(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, VkBuffer draw_buffer, + VkDeviceSize draw_buffer_offset, uint32_t draw_count, VkBuffer count_buffer, + VkDeviceSize count_buffer_offset, const char *vuid) { + FirstInstance(gpuav, cb_state, loc, draw_buffer, draw_buffer_offset, sizeof(VkDrawIndirectCommand), vvl::Struct::VkDrawIndirectCommand, 3, + draw_count, count_buffer, count_buffer_offset, vuid); +} + +template <> +void FirstInstance(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, + VkBuffer draw_buffer, VkDeviceSize draw_buffer_offset, uint32_t draw_count, + VkBuffer count_buffer, VkDeviceSize count_buffer_offset, const char *vuid) { + FirstInstance(gpuav, cb_state, loc, draw_buffer, draw_buffer_offset, sizeof(VkDrawIndexedIndirectCommand), + vvl::Struct::VkDrawIndexedIndirectCommand, 4, draw_count, count_buffer, count_buffer_offset, vuid); +} + +struct CountBufferValidationShader { + static size_t GetSpirvDwordsCount() { return cmd_validation_count_buffer_vert_size; } + static const uint32_t *GetSpirv() { return cmd_validation_count_buffer_vert; } + + static const uint32_t desc_set_id = gpuav::glsl::kDiagPerCmdDescriptorSet; + + glsl::CountBufferPushData push_constants{}; + gpu::BoundStorageBuffer count_buffer_binding = {gpuav::glsl::kPreDrawBinding_CountBuffer}; + + static std::vector GetDescriptorSetLayoutBindings() { + std::vector bindings = { + {gpuav::glsl::kPreDrawBinding_CountBuffer, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT, + nullptr}, // count buffer + }; + + return bindings; + } + + std::vector GetDescriptorWrites(VkDescriptorSet desc_set) { + std::vector desc_writes(1); + + desc_writes[0] = vku::InitStructHelper(); + desc_writes[0].dstSet = desc_set; + desc_writes[0].dstBinding = count_buffer_binding.binding; + desc_writes[0].dstArrayElement = 0; + desc_writes[0].descriptorCount = 1; + desc_writes[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + desc_writes[0].pBufferInfo = &count_buffer_binding.info; + + return desc_writes; + } +}; + +void CountBuffer(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, VkBuffer draw_buffer, + VkDeviceSize draw_buffer_offset, uint32_t draw_indirect_struct_byte_size, vvl::Struct draw_indirect_struct_name, + uint32_t draw_cmds_byte_stride, VkBuffer count_buffer, VkDeviceSize count_buffer_offset, + const char *vuid_draw_buffer_size, const char *vuid_max_draw_count) { + if (!gpuav.gpuav_settings.validate_indirect_draws_buffers) { + return; + } + + if (!gpuav.enabled_features.shaderInt64) { + return; + } + + if (cb_state.activeRenderPass->use_dynamic_rendering_inherited) { + // Unhandled for now + return; } - const VkDescriptorSet draw_validation_desc_set = - cb_state.gpu_resources_manager.GetManagedDescriptorSet(shared_draw_resources.ds_layout); - if (draw_validation_desc_set == VK_NULL_HANDLE) { - gpuav.InternalError(cb_state.VkHandle(), loc, "Unable to allocate descriptor set."); + RestorablePipelineState restorable_state(gpuav, cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS); + + auto &shared_draw_validation_resources = gpuav.shared_resources_manager.Get(gpuav, loc); + if (!shared_draw_validation_resources.valid) return; + auto &validation_pipeline = gpuav.shared_resources_manager.Get>( + gpuav, loc, cb_state.GetValidationCmdCommonDescriptorSetLayout()); + if (!validation_pipeline.valid) return; + + auto draw_buffer_state = gpuav.Get(draw_buffer); + if (!draw_buffer_state) { + gpuav.InternalError(LogObjectList(cb_state.VkHandle(), draw_buffer), loc, "buffer must be a valid VkBuffer handle"); return; } - std::vector buffer_infos; - buffer_infos.emplace_back(VkDescriptorBufferInfo{indirect_buffer, 0, VK_WHOLE_SIZE}); - if (count_buffer) { - buffer_infos.emplace_back(VkDescriptorBufferInfo{count_buffer, 0, VK_WHOLE_SIZE}); - } - - std::vector desc_writes{}; - for (size_t i = 0; i < buffer_infos.size(); ++i) { - VkWriteDescriptorSet &desc_write = desc_writes.emplace_back(); - desc_write = vku::InitStructHelper(); - desc_write.dstBinding = uint32_t(i); - desc_write.descriptorCount = 1; - desc_write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - desc_write.pBufferInfo = &buffer_infos[i]; - desc_write.dstSet = draw_validation_desc_set; - } - DispatchUpdateDescriptorSets(gpuav.device, static_cast(desc_writes.size()), desc_writes.data(), 0, NULL); - - // Insert a draw that can examine some device memory right before the draw we're validating (Pre Draw Validation) - // - // NOTE that this validation does not attempt to abort invalid api calls as most other validation does. A crash - // or DEVICE_LOST resulting from the invalid call will prevent preceeding validation errors from being reported. - - // Save current graphics pipeline state - const vvl::Func command = loc.function; - RestorablePipelineState restorable_state(cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS); - using vvl::Func; - const bool is_mesh_call = - (command == Func::vkCmdDrawMeshTasksIndirectCountEXT || command == Func::vkCmdDrawMeshTasksIndirectCountNV || - command == Func::vkCmdDrawMeshTasksIndirectEXT || command == Func::vkCmdDrawMeshTasksIndirectNV); - - const bool is_count_call = - (command == Func::vkCmdDrawIndirectCount || command == Func::vkCmdDrawIndirectCountKHR || - command == Func::vkCmdDrawIndexedIndirectCount || command == Func::vkCmdDrawIndexedIndirectCountKHR || - command == Func::vkCmdDrawMeshTasksIndirectCountEXT || command == Func::vkCmdDrawMeshTasksIndirectCountNV); - - uint32_t push_constants[kPushConstantDWords] = {}; - VkDeviceSize indirect_buffer_size = 0; - if (is_count_call) { - // Validate count buffer - if (count_buffer_offset > std::numeric_limits::max()) { - gpuav.InternalError(cb_state.VkHandle(), loc, - "Count buffer offset is larger than can be contained in an unsigned int."); + // Setup shader resources + // --- + { + CountBufferValidationShader shader_resources; + shader_resources.push_constants.draw_cmds_byte_stride = draw_cmds_byte_stride; + shader_resources.push_constants.draw_buffer_offset = draw_buffer_offset; + shader_resources.push_constants.draw_buffer_size = draw_buffer_state->create_info.size; + shader_resources.push_constants.draw_cmd_byte_size = draw_indirect_struct_byte_size; + shader_resources.push_constants.device_limit_max_draw_indirect_count = gpuav.phys_dev_props.limits.maxDrawIndirectCount; + + shader_resources.count_buffer_binding.info = {count_buffer, count_buffer_offset, sizeof(uint32_t)}; + + validation_pipeline.BindShaderResources(gpuav, cb_state, shader_resources); + } + + // Setup validation pipeline + // --- + { + VkPipeline pipeline_handle = + GetDrawValidationPipeline(gpuav, validation_pipeline.render_passes_to_pipeline, validation_pipeline.pipeline_layout, + validation_pipeline.shader_module, cb_state.activeRenderPass.get()->VkHandle(), loc); + if (pipeline_handle == VK_NULL_HANDLE) { + gpuav.InternalError(cb_state.VkHandle(), loc, "Could not find or create a pipeline."); return; } - // Buffer size must be >= (stride * (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) - uint32_t struct_size; - if (command == Func::vkCmdDrawIndirectCount || command == Func::vkCmdDrawIndirectCountKHR) { - struct_size = sizeof(VkDrawIndirectCommand); - } else if (command == Func::vkCmdDrawIndexedIndirectCount || command == Func::vkCmdDrawIndexedIndirectCountKHR) { - struct_size = sizeof(VkDrawIndexedIndirectCommand); - } else { - assert(command == Func::vkCmdDrawMeshTasksIndirectCountEXT || command == Func::vkCmdDrawMeshTasksIndirectCountNV); - struct_size = sizeof(VkDrawMeshTasksIndirectCommandEXT); - } - auto indirect_buffer_state = gpuav.Get(indirect_buffer); - indirect_buffer_size = indirect_buffer_state->create_info.size; - const uint64_t first_command_bytes = struct_size + indirect_offset; - uint32_t max_count; - if (first_command_bytes > indirect_buffer_size) { - max_count = 0; - } else { - max_count = 1 + static_cast(std::floor(((indirect_buffer_size - first_command_bytes) / stride))); - } - - assert(gpuav.phys_dev_props.limits.maxDrawIndirectCount > 0); - push_constants[0] = (is_mesh_call) ? glsl::kPreDrawSelectMeshCountBuffer : glsl::kPreDrawSelectCountBuffer; - push_constants[1] = gpuav.phys_dev_props.limits.maxDrawIndirectCount; - push_constants[2] = max_count; - push_constants[3] = static_cast((count_buffer_offset / sizeof(uint32_t))); - } else if ((command == Func::vkCmdDrawIndirect || command == Func::vkCmdDrawIndexedIndirect) && - !gpuav.enabled_features.drawIndirectFirstInstance) { - // Validate buffer for firstInstance check instead of count buffer check - push_constants[0] = glsl::kPreDrawSelectDrawBuffer; - push_constants[1] = draw_count; - if (command == Func::vkCmdDrawIndirect) { - push_constants[2] = - static_cast((indirect_offset + offsetof(struct VkDrawIndirectCommand, firstInstance)) / sizeof(uint32_t)); - } else { - assert(command == Func::vkCmdDrawIndexedIndirect); - push_constants[2] = static_cast( - (indirect_offset + offsetof(struct VkDrawIndexedIndirectCommand, firstInstance)) / sizeof(uint32_t)); - } - push_constants[3] = stride / sizeof(uint32_t); - } - - bool emit_task_error = false; - if (is_mesh_call && gpuav.phys_dev_props.limits.maxPushConstantsSize >= kPushConstantDWords * sizeof(uint32_t)) { - if (!is_count_call) { - // Select was set in count check for count call - push_constants[0] = glsl::kPreDrawSelectMeshNoCount; - } - const VkShaderStageFlags stages = pipeline_state->create_info_shaders; - push_constants[4] = static_cast(indirect_offset / sizeof(uint32_t)); - push_constants[5] = is_count_call ? 0 : draw_count; - push_constants[6] = stride / sizeof(uint32_t); - if (stages & VK_SHADER_STAGE_TASK_BIT_EXT) { - emit_task_error = true; - push_constants[7] = gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxTaskWorkGroupCount[0]; - push_constants[8] = gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxTaskWorkGroupCount[1]; - push_constants[9] = gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxTaskWorkGroupCount[2]; - push_constants[10] = gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxTaskWorkGroupTotalCount; - } else { - push_constants[7] = gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxMeshWorkGroupCount[0]; - push_constants[8] = gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxMeshWorkGroupCount[1]; - push_constants[9] = gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxMeshWorkGroupCount[2]; - push_constants[10] = gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxMeshWorkGroupTotalCount; - } - } - - // Insert diagnostic draw - if (use_shader_objects) { - std::array stages{{VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, - VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, VK_SHADER_STAGE_GEOMETRY_BIT, - VK_SHADER_STAGE_FRAGMENT_BIT}}; - std::array shaders{{ - shared_draw_resources.shader_object, - VK_NULL_HANDLE, - VK_NULL_HANDLE, - VK_NULL_HANDLE, - VK_NULL_HANDLE, - }}; - DispatchCmdBindShadersEXT(cb_state.VkHandle(), static_cast(stages.size()), stages.data(), shaders.data()); - } else { - DispatchCmdBindPipeline(cb_state.VkHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, validation_pipeline); - } - static_assert(sizeof(push_constants) <= 128, "push_constants buffer size >128, need to consider maxPushConstantsSize."); - DispatchCmdPushConstants(cb_state.VkHandle(), shared_draw_resources.pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 0, - static_cast(sizeof(push_constants)), push_constants); - BindValidationCmdsCommonDescSet(gpuav, cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS, shared_draw_resources.pipeline_layout, - cb_state.draw_index, static_cast(cb_state.per_command_error_loggers.size())); - DispatchCmdBindDescriptorSets(cb_state.VkHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, shared_draw_resources.pipeline_layout, - glsl::kDiagPerCmdDescriptorSet, 1, &draw_validation_desc_set, 0, nullptr); - DispatchCmdDraw(cb_state.VkHandle(), 3, 1, 0, 0); // TODO: this 3 assumes triangles I think, probably could be 1? - - CommandBuffer::ErrorLoggerFunc error_logger = [loc, indirect_buffer, indirect_offset, stride, indirect_buffer_size, - emit_task_error](Validator &gpuav, const uint32_t *error_record, - const LogObjectList &objlist) { - bool skip = false; + DispatchCmdBindPipeline(cb_state.VkHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_handle); - using namespace glsl; + DispatchCmdDraw(cb_state.VkHandle(), 1, 1, 0, 0); + } - if (error_record[kHeaderErrorGroupOffset] != kErrorGroupGpuPreDraw) { - assert(false); - return skip; - } + // Register error logger + // --- + CommandBuffer::ErrorLoggerFunc error_logger = [loc, draw_buffer, draw_buffer_size = draw_buffer_state->create_info.size, + draw_buffer_offset, draw_indirect_struct_byte_size, draw_cmds_byte_stride, + draw_indirect_struct_name, vuid_draw_buffer_size, + vuid_max_draw_count](Validator &gpuav, const uint32_t *error_record, + const LogObjectList &objlist) { + bool skip = false; - const GpuVuid &vuids = GetGpuVuid(loc.function); + using namespace glsl; switch (error_record[kHeaderErrorSubCodeOffset]) { - case kErrorSubCodePreDrawBufferSize: { - // Buffer size must be >= (stride * (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) + case kErrorSubCodePreDraw_DrawBufferSize: { const uint32_t count = error_record[kPreActionParamOffset_0]; - const uint32_t offset = static_cast(indirect_offset); // TODO: why cast to uin32_t? If it is changed, - // think about also doing it in the error message - const uint32_t draw_size = (stride * (count - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)); - - const char *vuid = nullptr; - if (count == 1) { - vuid = vuids.count_exceeds_bufsize_1; - } else { - vuid = vuids.count_exceeds_bufsize; - } - skip |= gpuav.LogError(vuid, objlist, loc, - "Indirect draw count of %" PRIu32 " would exceed buffer size %" PRIu64 - " of buffer %s " - "stride = %" PRIu32 " offset = %" PRIu32 - " (stride * (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) = %" PRIu32 ".", - count, indirect_buffer_size, gpuav.FormatHandle(indirect_buffer).c_str(), stride, offset, - draw_size); + + const VkDeviceSize draw_size = + (draw_cmds_byte_stride * (count - 1) + draw_buffer_offset + draw_indirect_struct_byte_size); + + skip |= gpuav.LogError(vuid_draw_buffer_size, objlist, loc, + "Indirect draw count of %" PRIu32 " would exceed size (%" PRIu64 + ") of buffer (%s). " + "stride = %" PRIu32 " offset = %" PRIu64 + " (stride * (drawCount - 1) + offset + sizeof(%s)) = %" PRIu64 ".", + count, draw_buffer_size, gpuav.FormatHandle(draw_buffer).c_str(), draw_cmds_byte_stride, + draw_buffer_offset, vvl::String(draw_indirect_struct_name), draw_size); break; } - case kErrorSubCodePreDrawCountLimit: { + case kErrorSubCodePreDraw_DrawCountLimit: { const uint32_t count = error_record[kPreActionParamOffset_0]; - skip |= gpuav.LogError(vuids.count_exceeds_device_limit, objlist, loc, + skip |= gpuav.LogError(vuid_max_draw_count, objlist, loc, "Indirect draw count of %" PRIu32 " would exceed maxDrawIndirectCount limit of %" PRIu32 ".", count, gpuav.phys_dev_props.limits.maxDrawIndirectCount); break; } - case kErrorSubCodePreDrawFirstInstance: { - const uint32_t index = error_record[kPreActionParamOffset_0]; - gpuav.LogError( - vuids.first_instance_not_zero, objlist, loc, - "The drawIndirectFirstInstance feature is not enabled, but the firstInstance member of the %s structure at " - "index %" PRIu32 " is not zero.", - String(loc.function), index); + default: + assert(false); + return skip; + } + + return skip; + }; + + cb_state.per_command_error_loggers.emplace_back(std::move(error_logger)); +} + +struct MeshValidationShader { + static size_t GetSpirvDwordsCount() { return cmd_validation_draw_mesh_indirect_vert_size; } + static const uint32_t *GetSpirv() { return cmd_validation_draw_mesh_indirect_vert; } + + static const uint32_t desc_set_id = gpuav::glsl::kDiagPerCmdDescriptorSet; + + glsl::DrawMeshPushData push_constants{}; + gpu::BoundStorageBuffer draw_buffer_binding = {gpuav::glsl::kPreDrawBinding_IndirectBuffer}; + gpu::BoundStorageBuffer count_buffer_binding = {gpuav::glsl::kPreDrawBinding_CountBuffer}; + + static std::vector GetDescriptorSetLayoutBindings() { + std::vector bindings = { + {gpuav::glsl::kPreDrawBinding_IndirectBuffer, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT, + nullptr}, // indirect buffer + {gpuav::glsl::kPreDrawBinding_CountBuffer, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT, + nullptr}, // count buffer + }; + + return bindings; + } + + std::vector GetDescriptorWrites(VkDescriptorSet desc_set) { + std::vector desc_writes(2); + + desc_writes[0] = vku::InitStructHelper(); + desc_writes[0].dstSet = desc_set; + desc_writes[0].dstBinding = draw_buffer_binding.binding; + desc_writes[0].dstArrayElement = 0; + desc_writes[0].descriptorCount = 1; + desc_writes[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + desc_writes[0].pBufferInfo = &draw_buffer_binding.info; + + desc_writes[1] = vku::InitStructHelper(); + desc_writes[1].dstSet = desc_set; + desc_writes[1].dstBinding = count_buffer_binding.binding; + desc_writes[1].dstArrayElement = 0; + desc_writes[1].descriptorCount = 1; + desc_writes[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + desc_writes[1].pBufferInfo = &count_buffer_binding.info; + + return desc_writes; + } +}; + +void DrawMeshIndirect(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, VkBuffer draw_buffer, + VkDeviceSize draw_buffer_offset, uint32_t draw_cmds_byte_stride, VkBuffer count_buffer, + VkDeviceSize count_buffer_offset, uint32_t draw_count, const DrawMeshIndirectVuids &vuids) { + if (!gpuav.gpuav_settings.validate_indirect_draws_buffers) { + return; + } + + if (cb_state.activeRenderPass->use_dynamic_rendering_inherited) { + // Unhandled for now + return; + } + + RestorablePipelineState restorable_state(gpuav, cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS); + + const auto lv_bind_point = ConvertToLvlBindPoint(VK_PIPELINE_BIND_POINT_GRAPHICS); + auto const &last_bound = cb_state.lastBound[lv_bind_point]; + const auto *pipeline_state = last_bound.pipeline_state; + + auto &shared_draw_validation_resources = gpuav.shared_resources_manager.Get(gpuav, loc); + if (!shared_draw_validation_resources.valid) return; + auto &validation_pipeline = gpuav.shared_resources_manager.Get>( + gpuav, loc, cb_state.GetValidationCmdCommonDescriptorSetLayout()); + if (!validation_pipeline.valid) return; + + auto draw_buffer_state = gpuav.Get(draw_buffer); + if (!draw_buffer_state) { + gpuav.InternalError(LogObjectList(cb_state.VkHandle(), draw_buffer), loc, "buffer must be a valid VkBuffer handle"); + return; + } + + const VkShaderStageFlags stages = pipeline_state->create_info_shaders; + const bool is_task_shader = (stages & VK_SHADER_STAGE_TASK_BIT_EXT) == VK_SHADER_STAGE_TASK_BIT_EXT; + + // Setup shader resources + // --- + { + MeshValidationShader shader_resources; + shader_resources.push_constants.draw_cmds_stride_dwords = draw_cmds_byte_stride / sizeof(uint32_t); + if (is_task_shader) { + shader_resources.push_constants.max_workgroup_count_x = + gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxTaskWorkGroupCount[0]; + shader_resources.push_constants.max_workgroup_count_y = + gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxTaskWorkGroupCount[1]; + shader_resources.push_constants.max_workgroup_count_z = + gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxTaskWorkGroupCount[2]; + shader_resources.push_constants.max_workgroup_total_count = + gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxTaskWorkGroupTotalCount; + } else { + shader_resources.push_constants.max_workgroup_count_x = + gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxMeshWorkGroupCount[0]; + shader_resources.push_constants.max_workgroup_count_y = + gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxMeshWorkGroupCount[1]; + shader_resources.push_constants.max_workgroup_count_z = + gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxMeshWorkGroupCount[2]; + shader_resources.push_constants.max_workgroup_total_count = + gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxMeshWorkGroupTotalCount; + } + + shader_resources.draw_buffer_binding.info = {draw_buffer, draw_buffer_offset, VK_WHOLE_SIZE}; + if (count_buffer != VK_NULL_HANDLE) { + shader_resources.push_constants.flags |= glsl::kDrawMeshFlags_DrawCountFromBuffer; + shader_resources.count_buffer_binding.info = {count_buffer, count_buffer_offset, sizeof(uint32_t)}; + } else { + shader_resources.count_buffer_binding.info = {shared_draw_validation_resources.dummy_buffer.buffer, 0, VK_WHOLE_SIZE}; + } + + validation_pipeline.BindShaderResources(gpuav, cb_state, shader_resources); + } + + // Setup validation pipeline + // --- + { + VkPipeline pipeline_handle = + GetDrawValidationPipeline(gpuav, validation_pipeline.render_passes_to_pipeline, validation_pipeline.pipeline_layout, + validation_pipeline.shader_module, cb_state.activeRenderPass.get()->VkHandle(), loc); + if (pipeline_handle == VK_NULL_HANDLE) { + gpuav.InternalError(cb_state.VkHandle(), loc, "Could not find or create a pipeline."); + return; + } + + DispatchCmdBindPipeline(cb_state.VkHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_handle); + + uint32_t max_held_draw_cmds = 0; + if (draw_buffer_state->create_info.size > draw_buffer_offset) { + max_held_draw_cmds = + static_cast((draw_buffer_state->create_info.size - draw_buffer_offset) / draw_cmds_byte_stride); + } + draw_count = std::min(draw_count, max_held_draw_cmds); + DispatchCmdDraw(cb_state.VkHandle(), draw_count, 1, 0, 0); + } + + // Register error logger + // --- + CommandBuffer::ErrorLoggerFunc error_logger = [loc, vuids, is_task_shader](Validator &gpuav, const uint32_t *error_record, + const LogObjectList &objlist) { + bool skip = false; + + using namespace glsl; + + const uint32_t draw_i = error_record[kPreActionParamOffset_1]; + const char *group_count_name = is_task_shader ? "maxTaskWorkGroupCount" : "maxMeshWorkGroupCount"; + const char *group_count_total_name = is_task_shader ? "maxTaskWorkGroupTotalCount" : "maxMeshWorkGroupTotalCount"; + + switch (error_record[kHeaderErrorSubCodeOffset]) { + case kErrorSubCodePreDrawGroupCountX: { + const char *vuid_group_count_exceeds_max = + is_task_shader ? vuids.task_group_count_exceeds_max_x : vuids.mesh_group_count_exceeds_max_x; + const uint32_t group_count_x = error_record[kPreActionParamOffset_0]; + const uint32_t limit = is_task_shader ? gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxTaskWorkGroupCount[0] + : gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxMeshWorkGroupCount[0]; + skip |= gpuav.LogError(vuid_group_count_exceeds_max, objlist, loc, + "In draw %" PRIu32 ", VkDrawMeshTasksIndirectCommandEXT::groupCountX is %" PRIu32 + " which is greater than VkPhysicalDeviceMeshShaderPropertiesEXT::%s[0]" + " (%" PRIu32 ").", + draw_i, group_count_x, group_count_name, limit); break; } - case kErrorSubCodePreDrawGroupCountX: - case kErrorSubCodePreDrawGroupCountY: + + case kErrorSubCodePreDrawGroupCountY: { + const char *vuid_group_count_exceeds_max = + is_task_shader ? vuids.task_group_count_exceeds_max_y : vuids.mesh_group_count_exceeds_max_y; + const uint32_t group_count_y = error_record[kPreActionParamOffset_0]; + const uint32_t limit = is_task_shader ? gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxTaskWorkGroupCount[1] + : gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxMeshWorkGroupCount[1]; + skip |= gpuav.LogError(vuid_group_count_exceeds_max, objlist, loc, + "In draw %" PRIu32 ", VkDrawMeshTasksIndirectCommandEXT::groupCountY is %" PRIu32 + " which is greater than VkPhysicalDeviceMeshShaderPropertiesEXT::%s[1]" + " (%" PRIu32 ").", + draw_i, group_count_y, group_count_name, limit); + break; + } + case kErrorSubCodePreDrawGroupCountZ: { - const uint32_t group_count = error_record[kPreActionParamOffset_0]; - const uint32_t draw_number = error_record[kPreActionParamOffset_1]; - const char *count_label; - uint32_t index; - uint32_t limit; - const char *vuid; - if (error_record[kHeaderErrorSubCodeOffset] == kErrorSubCodePreDrawGroupCountX) { - count_label = "groupCountX"; - index = 0; - vuid = emit_task_error ? vuids.task_group_count_exceeds_max_x : vuids.mesh_group_count_exceeds_max_x; - limit = gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxMeshWorkGroupCount[0]; - } else if (error_record[kHeaderErrorSubCodeOffset] == kErrorSubCodePreDrawGroupCountY) { - count_label = "groupCountY"; - index = 1; - vuid = emit_task_error ? vuids.task_group_count_exceeds_max_y : vuids.mesh_group_count_exceeds_max_y; - limit = gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxMeshWorkGroupCount[1]; - } else { - assert(error_record[kHeaderErrorSubCodeOffset] == kErrorSubCodePreDrawGroupCountZ); - count_label = "groupCountZ"; - index = 2; - vuid = emit_task_error ? vuids.task_group_count_exceeds_max_z : vuids.mesh_group_count_exceeds_max_z; - limit = gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxMeshWorkGroupCount[2]; - } - skip |= - gpuav.LogError(vuid, objlist, loc, - "In draw %" PRIu32 ", %s is %" PRIu32 - " which is greater than VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupCount[%" PRIu32 - "] (%" PRIu32 ").", - draw_number, count_label, group_count, index, limit); + const char *vuid_group_count_exceeds_max = + is_task_shader ? vuids.task_group_count_exceeds_max_z : vuids.mesh_group_count_exceeds_max_z; + const uint32_t group_count_z = error_record[kPreActionParamOffset_0]; + const uint32_t limit = is_task_shader ? gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxTaskWorkGroupCount[2] + : gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxMeshWorkGroupCount[2]; + skip |= gpuav.LogError(vuid_group_count_exceeds_max, objlist, loc, + "In draw %" PRIu32 ", VkDrawMeshTasksIndirectCommandEXT::groupCountZ is %" PRIu32 + " which is greater than VkPhysicalDeviceMeshShaderPropertiesEXT::%s[2]" + " (%" PRIu32 ").", + draw_i, group_count_z, group_count_name, limit); break; } - case kErrorSubCodePreDrawGroupCountTotal: { - const uint32_t total_count = error_record[kPreActionParamOffset_0]; - const uint32_t draw_number = error_record[kPreActionParamOffset_1]; - auto vuid = emit_task_error ? vuids.task_group_count_exceeds_max_total : vuids.mesh_group_count_exceeds_max_total; - skip |= gpuav.LogError( - vuid, objlist, loc, - "In draw %" PRIu32 ", The product of groupCountX, groupCountY and groupCountZ (%" PRIu32 - ") is greater than VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupTotalCount (%" PRIu32 ").", - draw_number, total_count, gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxTaskWorkGroupTotalCount); + case kErrorSubCodePreDrawGroupCountTotal: { + const char *vuid_group_count_exceeds_max = + is_task_shader ? vuids.task_group_count_exceeds_max_total : vuids.mesh_group_count_exceeds_max_total; + const uint32_t group_count_total = error_record[kPreActionParamOffset_0]; + const uint32_t limit = is_task_shader ? gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxTaskWorkGroupTotalCount + : gpuav.phys_dev_ext_props.mesh_shader_props_ext.maxMeshWorkGroupTotalCount; + skip |= gpuav.LogError(vuid_group_count_exceeds_max, objlist, loc, + "In draw %" PRIu32 ", size of VkDrawMeshTasksIndirectCommandEXT is %" PRIu32 + " which is greater than VkPhysicalDeviceMeshShaderPropertiesEXT::%s" + " (%" PRIu32 ").", + draw_i, group_count_total, group_count_total_name, limit); break; } + default: + assert(false); + return skip; + } + + return skip; + }; + + cb_state.per_command_error_loggers.emplace_back(std::move(error_logger)); +} + +struct IndexBufferValidationShader { + static size_t GetSpirvDwordsCount() { return cmd_validation_draw_indexed_vert_size; } + static const uint32_t *GetSpirv() { return cmd_validation_draw_indexed_vert; } + + static const uint32_t desc_set_id = gpuav::glsl::kDiagPerCmdDescriptorSet; + + glsl::IndexedDrawPushData push_constants{}; + gpu::BoundStorageBuffer index_buffer_binding = {gpuav::glsl::kPreDrawBinding_IndexBuffer}; + + static std::vector GetDescriptorSetLayoutBindings() { + std::vector bindings = { + {gpuav::glsl::kPreDrawBinding_IndexBuffer, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT, nullptr}}; + + return bindings; + } + + std::vector GetDescriptorWrites(VkDescriptorSet desc_set) { + std::vector desc_writes(1); + + desc_writes[0] = vku::InitStructHelper(); + desc_writes[0].dstSet = desc_set; + desc_writes[0].dstBinding = index_buffer_binding.binding; + desc_writes[0].dstArrayElement = 0; + desc_writes[0].descriptorCount = 1; + desc_writes[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + desc_writes[0].pBufferInfo = &index_buffer_binding.info; + + return desc_writes; + } +}; + +struct SmallestVertexBufferBinding { + VkDeviceSize min_vertex_attributes_count = std::numeric_limits::max(); + uint32_t binding = std::numeric_limits::max(); + vvl::VertexBufferBinding binding_info{}; +}; +// Computes the smallest vertex attributes count among the set of bound vertex buffers. +// Used to detect out of bounds indices in index buffers. +// If no vertex buffer is bound, min_vertex_attributes_count is std::numeric_limits::max() +// indicating that no index can be out of bound +static SmallestVertexBufferBinding SmallestVertexAttributesCount(const vvl::CommandBuffer &cb_state) { + // If there is no bound vertex buffers, cannot have + + const auto lv_bind_point = ConvertToLvlBindPoint(VK_PIPELINE_BIND_POINT_GRAPHICS); + auto const &last_bound = cb_state.lastBound[lv_bind_point]; + const auto *pipeline_state = last_bound.pipeline_state; + const bool use_shader_objects = pipeline_state == nullptr; + + const bool dynamic_vertex_input = use_shader_objects || pipeline_state->IsDynamic(CB_DYNAMIC_STATE_VERTEX_INPUT_EXT); + + const auto &vertex_binding_descriptions = + dynamic_vertex_input ? cb_state.dynamic_state_value.vertex_bindings : pipeline_state->vertex_input_state->bindings; + + SmallestVertexBufferBinding smallest_vertex_buffer_binding; + + for (const auto &[binding, vertex_binding_desc] : vertex_binding_descriptions) { + auto find_vbb = cb_state.current_vertex_buffer_binding_info.find(binding); + if (find_vbb == cb_state.current_vertex_buffer_binding_info.cend()) { + // This is a validation error + continue; + } + + const vvl::VertexBufferBinding &vbb = find_vbb->second; + + for (const auto &[Location, attrib] : vertex_binding_desc.locations) { + const VkDeviceSize attribute_size = vkuFormatElementSize(attrib.desc.format); + + const VkDeviceSize stride = vbb.stride; // Tracked stride should already handle all possible value origin + + if (vbb.size < (vbb.offset + attrib.desc.offset)) { + // overflow will occur + continue; + } + VkDeviceSize vertex_buffer_remaining_size = vbb.size - vbb.offset - attrib.desc.offset; + + VkDeviceSize vertex_attributes_count = 0; + vertex_attributes_count = vertex_buffer_remaining_size / stride; + vertex_buffer_remaining_size -= vertex_attributes_count * stride; + + // maybe room for one more attribute but not full stride - not having stride space does not matter for last element + if (vertex_buffer_remaining_size >= attribute_size) { + vertex_attributes_count += 1; + } + + smallest_vertex_buffer_binding.min_vertex_attributes_count = + std::min(smallest_vertex_buffer_binding.min_vertex_attributes_count, vertex_attributes_count); + if (smallest_vertex_buffer_binding.min_vertex_attributes_count == vertex_attributes_count) { + smallest_vertex_buffer_binding.binding = binding; + smallest_vertex_buffer_binding.binding_info = vbb; + } + } + } + return smallest_vertex_buffer_binding; +} + +void DrawIndexed(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, uint32_t index_count, uint32_t first_index, + uint32_t vertex_offset, const char *vuid_oob_vertex) { + if (!gpuav.gpuav_settings.validate_index_buffers) { + return; + } + + if (gpuav.enabled_features.robustBufferAccess) { + return; + } + + if (!cb_state.index_buffer_binding.buffer) { + return; + } + + if (cb_state.activeRenderPass->use_dynamic_rendering_inherited) { + // Unhandled for now + return; + } + + const SmallestVertexBufferBinding smallest_vertex_buffer_binding = SmallestVertexAttributesCount(cb_state); + if (smallest_vertex_buffer_binding.min_vertex_attributes_count == std::numeric_limits::max()) { + // cannot overrun index buffer, skip validation + return; + } + + RestorablePipelineState restorable_state(gpuav, cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS); + + auto &shared_draw_validation_resources = gpuav.shared_resources_manager.Get(gpuav, loc); + if (!shared_draw_validation_resources.valid) return; + auto &validation_pipeline = gpuav.shared_resources_manager.Get>( + gpuav, loc, cb_state.GetValidationCmdCommonDescriptorSetLayout()); + if (!validation_pipeline.valid) return; + + const uint32_t index_bits_size = GetIndexBitsSize(cb_state.index_buffer_binding.index_type); + const uint32_t max_indices_in_buffer = static_cast(cb_state.index_buffer_binding.size / (index_bits_size / 8u)); + + { + IndexBufferValidationShader shader_resources; + shader_resources.push_constants.smallest_vertex_attributes_count = + static_cast(smallest_vertex_buffer_binding.min_vertex_attributes_count); + shader_resources.push_constants.index_width = index_bits_size; + shader_resources.push_constants.vertex_offset = vertex_offset; + + shader_resources.index_buffer_binding.info = {cb_state.index_buffer_binding.buffer, cb_state.index_buffer_binding.offset, + cb_state.index_buffer_binding.size}; + + validation_pipeline.BindShaderResources(gpuav, cb_state, shader_resources); + } + + { + VkPipeline pipeline_handle = + GetDrawValidationPipeline(gpuav, validation_pipeline.render_passes_to_pipeline, validation_pipeline.pipeline_layout, + validation_pipeline.shader_module, cb_state.activeRenderPass.get()->VkHandle(), loc); + if (pipeline_handle == VK_NULL_HANDLE) { + gpuav.InternalError(cb_state.VkHandle(), loc, "Could not find or create a pipeline."); + return; + } + + DispatchCmdBindPipeline(cb_state.VkHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_handle); + + // Do not overrun index buffer + const uint32_t draw_count = std::min(index_count, max_indices_in_buffer); + DispatchCmdDraw(cb_state.VkHandle(), draw_count, 1, first_index, 0); + } + + CommandBuffer::ErrorLoggerFunc error_logger = + [loc, vuid_oob_vertex, smallest_vertex_buffer_binding, index_buffer_binding = cb_state.index_buffer_binding, + max_indices_in_buffer](Validator &gpuav, const uint32_t *error_record, const LogObjectList &objlist) { + bool skip = false; + + using namespace glsl; + + switch (error_record[kHeaderErrorSubCodeOffset]) { + case kErrorSubCode_OobVertexBuffer: { + const uint32_t index_buffer_offset = error_record[kPreActionParamOffset_0]; + const int32_t vertex_offset = static_cast(error_record[kPreActionParamOffset_1]); + const uint32_t vertex_index = error_record[kPreActionParamOffset_2]; + const uint32_t index_buffer_value = static_cast(int32_t(vertex_index) - vertex_offset); + + gpuav.LogError(vuid_oob_vertex, objlist, loc, + "Vertex index %" PRIu32 + " is not within the smallest bound vertex buffer.\n" + "index_buffer[%" PRIu32 "] (%" PRIu32 ") + vertexOffset (%" PRIi32 ") = Vertex index %" PRIu32 + "\n" + + "Smallest vertex buffer binding info:\n" + "- Buffer: %s\n" + "- Binding: %" PRIu32 + "\n" + "- Binding offset: %" PRIu64 + "\n" + "- Binding size: %" PRIu64 + " bytes\n" + + "Index buffer binding info:\n" + "- Buffer: %s\n" + "- Index type: %s\n" + "- Binding offset: %" PRIu64 + "\n" + "- Binding size: %" PRIu64 " bytes (or %" PRIu32 " %s)\n", + // OOB vertex index info + vertex_index, index_buffer_offset, index_buffer_value, vertex_offset, vertex_index, + + // Vertex buffer binding info + gpuav.FormatHandle(smallest_vertex_buffer_binding.binding_info.buffer).c_str(), + smallest_vertex_buffer_binding.binding, smallest_vertex_buffer_binding.binding_info.offset, + smallest_vertex_buffer_binding.binding_info.size, + + // Index buffer binding info + gpuav.FormatHandle(index_buffer_binding.buffer).c_str(), + string_VkIndexType(index_buffer_binding.index_type), index_buffer_binding.offset, + index_buffer_binding.size, max_indices_in_buffer, + string_VkIndexType(index_buffer_binding.index_type)); + break; + } + + default: + assert(false); + return skip; + } + + return skip; + }; + + cb_state.per_command_error_loggers.emplace_back(std::move(error_logger)); +} + +struct DrawIndexedIndirectIndexBufferShader { + static size_t GetSpirvDwordsCount() { return cmd_validation_draw_indexed_indirect_index_buffer_vert_size; } + static const uint32_t *GetSpirv() { return cmd_validation_draw_indexed_indirect_index_buffer_vert; } + + static const uint32_t desc_set_id = gpuav::glsl::kDiagPerCmdDescriptorSet; + + glsl::DrawIndexedIndirectIndexBufferPushData push_constants{}; + gpu::BoundStorageBuffer draw_buffer_binding = {gpuav::glsl::kPreDrawBinding_IndirectBuffer}; + gpu::BoundStorageBuffer count_buffer_binding = {gpuav::glsl::kPreDrawBinding_CountBuffer}; + gpu::BoundStorageBuffer index_buffer_binding = {gpuav::glsl::kPreDrawBinding_IndexBuffer}; + + static std::vector GetDescriptorSetLayoutBindings() { + std::vector bindings = { + {gpuav::glsl::kPreDrawBinding_IndirectBuffer, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT, + nullptr}, + {gpuav::glsl::kPreDrawBinding_CountBuffer, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT, nullptr}, + {gpuav::glsl::kPreDrawBinding_IndexBuffer, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT, nullptr}}; + + return bindings; + } + + std::vector GetDescriptorWrites(VkDescriptorSet desc_set) { + std::vector desc_writes(3); + + desc_writes[0] = vku::InitStructHelper(); + desc_writes[0].dstSet = desc_set; + desc_writes[0].dstBinding = draw_buffer_binding.binding; + desc_writes[0].dstArrayElement = 0; + desc_writes[0].descriptorCount = 1; + desc_writes[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + desc_writes[0].pBufferInfo = &draw_buffer_binding.info; + + desc_writes[1] = vku::InitStructHelper(); + desc_writes[1].dstSet = desc_set; + desc_writes[1].dstBinding = count_buffer_binding.binding; + desc_writes[1].dstArrayElement = 0; + desc_writes[1].descriptorCount = 1; + desc_writes[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + desc_writes[1].pBufferInfo = &count_buffer_binding.info; + + desc_writes[2] = vku::InitStructHelper(); + desc_writes[2].dstSet = desc_set; + desc_writes[2].dstBinding = index_buffer_binding.binding; + desc_writes[2].dstArrayElement = 0; + desc_writes[2].descriptorCount = 1; + desc_writes[2].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + desc_writes[2].pBufferInfo = &index_buffer_binding.info; + + return desc_writes; + } +}; + +void DrawIndexedIndirectIndexBuffer(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, VkBuffer draw_buffer, + VkDeviceSize draw_buffer_offset, uint32_t draw_cmds_byte_stride, uint32_t draw_count, + VkBuffer count_buffer, VkDeviceSize count_buffer_offset, const char *vuid_oob_index) { + if (!gpuav.gpuav_settings.validate_index_buffers) { + return; + } + + if (gpuav.enabled_features.robustBufferAccess2) { + return; + } + + if (!cb_state.index_buffer_binding.buffer) { + return; + } + + if (cb_state.activeRenderPass->use_dynamic_rendering_inherited) { + // Unhandled for now + return; + } + + RestorablePipelineState restorable_state(gpuav, cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS); + + auto &shared_draw_validation_resources = gpuav.shared_resources_manager.Get(gpuav, loc); + if (!shared_draw_validation_resources.valid) return; + auto &validation_pipeline = + gpuav.shared_resources_manager.Get>( + gpuav, loc, cb_state.GetValidationCmdCommonDescriptorSetLayout()); + if (!validation_pipeline.valid) return; + + const uint32_t index_bits_size = GetIndexBitsSize(cb_state.index_buffer_binding.index_type); + const uint32_t max_indices_in_buffer = static_cast(cb_state.index_buffer_binding.size / (index_bits_size / 8u)); + { + DrawIndexedIndirectIndexBufferShader shader_resources; + if (count_buffer != VK_NULL_HANDLE) { + shader_resources.push_constants.flags |= glsl::kIndexedIndirectDrawFlags_DrawCountFromBuffer; + shader_resources.count_buffer_binding.info = {count_buffer, count_buffer_offset, sizeof(uint32_t)}; + } else { + shader_resources.count_buffer_binding.info = {shared_draw_validation_resources.dummy_buffer.buffer, 0, VK_WHOLE_SIZE}; + } + + shader_resources.push_constants.draw_cmds_stride_dwords = draw_cmds_byte_stride / sizeof(uint32_t); + shader_resources.push_constants.bound_index_buffer_indices_count = max_indices_in_buffer; + shader_resources.push_constants.cpu_draw_count = draw_count; + + shader_resources.draw_buffer_binding.info = {draw_buffer, draw_buffer_offset, VK_WHOLE_SIZE}; + shader_resources.index_buffer_binding.info = {cb_state.index_buffer_binding.buffer, cb_state.index_buffer_binding.offset, + cb_state.index_buffer_binding.size}; + + validation_pipeline.BindShaderResources(gpuav, cb_state, shader_resources); + } + + { + VkPipeline pipeline_handle = + GetDrawValidationPipeline(gpuav, validation_pipeline.render_passes_to_pipeline, validation_pipeline.pipeline_layout, + validation_pipeline.shader_module, cb_state.activeRenderPass.get()->VkHandle(), loc); + if (pipeline_handle == VK_NULL_HANDLE) { + gpuav.InternalError(cb_state.VkHandle(), loc, "Could not find or create a pipeline."); + return; + } + + DispatchCmdBindPipeline(cb_state.VkHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_handle); + + // One draw will check all VkDrawIndexedIndirectCommand + DispatchCmdDraw(cb_state.VkHandle(), 1, 1, 0, 0); + } + + CommandBuffer::ErrorLoggerFunc error_logger = [loc, vuid_oob_index, draw_buffer, draw_buffer_offset, draw_cmds_byte_stride, + index_buffer_binding = cb_state.index_buffer_binding, + max_indices_in_buffer](Validator &gpuav, const uint32_t *error_record, + const LogObjectList &objlist) { + bool skip = false; + + using namespace glsl; + + switch (error_record[kHeaderErrorSubCodeOffset]) { + case kErrorSubCode_OobIndexBuffer: { + const uint32_t draw_i = error_record[kPreActionParamOffset_0]; + const uint32_t first_index = error_record[kPreActionParamOffset_1]; + const uint32_t index_count = error_record[kPreActionParamOffset_2]; + const uint32_t highest_accessed_index = first_index + index_count; + + gpuav.LogError( + vuid_oob_index, objlist, loc, + "Index %" PRIu32 " is not within the bound index buffer. Computed from VkDrawIndexedIndirectCommand[%" PRIu32 + "] (.firstIndex = %" PRIu32 ", .indexCount = %" PRIu32 + "), stored in %s\n" + + "Index buffer binding info:\n" + "- Buffer: %s\n" + "- Index type: %s\n" + "- Binding offset: %" PRIu64 + "\n" + "- Binding size: %" PRIu64 " bytes (or %" PRIu32 + " %s)\n" + + "Supplied buffer parameters in indirect command: offset = %" PRIu64 ", stride = %" PRIu32 " bytes.", + // OOB index info + highest_accessed_index, draw_i, first_index, index_count, gpuav.FormatHandle(draw_buffer).c_str(), + + // Index buffer binding info + gpuav.FormatHandle(index_buffer_binding.buffer).c_str(), string_VkIndexType(index_buffer_binding.index_type), + index_buffer_binding.offset, index_buffer_binding.size, max_indices_in_buffer, + string_VkIndexType(index_buffer_binding.index_type), + + // VkDrawIndexedIndirectCommand info + draw_buffer_offset, draw_cmds_byte_stride); break; + } + + default: + assert(false); + return skip; } return skip; @@ -470,4 +1135,267 @@ void InsertIndirectDrawValidation(Validator &gpuav, const Location &loc, Command cb_state.per_command_error_loggers.emplace_back(std::move(error_logger)); } +struct DrawIndexedIndirectVertexBufferShader { + static size_t GetSpirvDwordsCount() { return cmd_validation_draw_indexed_indirect_vertex_buffer_vert_size; } + static const uint32_t *GetSpirv() { return cmd_validation_draw_indexed_indirect_vertex_buffer_vert; } + + static const uint32_t desc_set_id = gpuav::glsl::kDiagPerCmdDescriptorSet; + + glsl::DrawIndexedIndirectVertexBufferPushData push_constants{}; + gpu::BoundStorageBuffer draw_buffer_binding = {gpuav::glsl::kPreDrawBinding_IndirectBuffer}; + gpu::BoundStorageBuffer count_buffer_binding = {gpuav::glsl::kPreDrawBinding_CountBuffer}; + gpu::BoundStorageBuffer index_buffer_binding = {gpuav::glsl::kPreDrawBinding_IndexBuffer}; + + static std::vector GetDescriptorSetLayoutBindings() { + std::vector bindings = { + {gpuav::glsl::kPreDrawBinding_IndirectBuffer, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT, + nullptr}, + {gpuav::glsl::kPreDrawBinding_CountBuffer, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT, nullptr}, + {gpuav::glsl::kPreDrawBinding_IndexBuffer, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT, nullptr}}; + + return bindings; + } + + std::vector GetDescriptorWrites(VkDescriptorSet desc_set) { + std::vector desc_writes(3); + + desc_writes[0] = vku::InitStructHelper(); + desc_writes[0].dstSet = desc_set; + desc_writes[0].dstBinding = draw_buffer_binding.binding; + desc_writes[0].dstArrayElement = 0; + desc_writes[0].descriptorCount = 1; + desc_writes[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + desc_writes[0].pBufferInfo = &draw_buffer_binding.info; + + desc_writes[1] = vku::InitStructHelper(); + desc_writes[1].dstSet = desc_set; + desc_writes[1].dstBinding = count_buffer_binding.binding; + desc_writes[1].dstArrayElement = 0; + desc_writes[1].descriptorCount = 1; + desc_writes[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + desc_writes[1].pBufferInfo = &count_buffer_binding.info; + + desc_writes[2] = vku::InitStructHelper(); + desc_writes[2].dstSet = desc_set; + desc_writes[2].dstBinding = index_buffer_binding.binding; + desc_writes[2].dstArrayElement = 0; + desc_writes[2].descriptorCount = 1; + desc_writes[2].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + desc_writes[2].pBufferInfo = &index_buffer_binding.info; + + return desc_writes; + } +}; + +void DrawIndexedIndirectVertexBuffer(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, VkBuffer draw_buffer, + VkDeviceSize draw_buffer_offset, uint32_t draw_cmds_byte_stride, uint32_t draw_count, + VkBuffer count_buffer, VkDeviceSize count_buffer_offset, const char *vuid_oob_vertex) { + if (!gpuav.gpuav_settings.validate_index_buffers) { + return; + } + + if (gpuav.enabled_features.robustBufferAccess) { + return; + } + + if (!cb_state.index_buffer_binding.buffer) { + return; + } + + if (cb_state.activeRenderPass->use_dynamic_rendering_inherited) { + // Unhandled for now + return; + } + + RestorablePipelineState restorable_state(gpuav, cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS); + + auto &shared_draw_validation_resources = gpuav.shared_resources_manager.Get(gpuav, loc); + if (!shared_draw_validation_resources.valid) return; + auto &validation_pipeline = + gpuav.shared_resources_manager.Get>( + gpuav, loc, cb_state.GetValidationCmdCommonDescriptorSetLayout()); + if (!validation_pipeline.valid) return; + + const uint32_t index_bits_size = GetIndexBitsSize(cb_state.index_buffer_binding.index_type); + const uint32_t max_indices_in_buffer = static_cast(cb_state.index_buffer_binding.size / (index_bits_size / 8u)); + const SmallestVertexBufferBinding smallest_vertex_buffer_binding = SmallestVertexAttributesCount(cb_state); + + { + DrawIndexedIndirectVertexBufferShader shader_resources; + if (count_buffer != VK_NULL_HANDLE) { + shader_resources.push_constants.flags |= glsl::kIndexedIndirectDrawFlags_DrawCountFromBuffer; + shader_resources.count_buffer_binding.info = {count_buffer, count_buffer_offset, sizeof(uint32_t)}; + } else { + shader_resources.count_buffer_binding.info = {shared_draw_validation_resources.dummy_buffer.buffer, 0, VK_WHOLE_SIZE}; + } + + shader_resources.push_constants.index_width = index_bits_size; + shader_resources.push_constants.draw_cmds_stride_dwords = draw_cmds_byte_stride / sizeof(uint32_t); + shader_resources.push_constants.bound_index_buffer_indices_count = max_indices_in_buffer; + shader_resources.push_constants.cpu_draw_count = draw_count; + + shader_resources.push_constants.smallest_vertex_attributes_count = + static_cast(smallest_vertex_buffer_binding.min_vertex_attributes_count); + + shader_resources.draw_buffer_binding.info = {draw_buffer, draw_buffer_offset, VK_WHOLE_SIZE}; + shader_resources.index_buffer_binding.info = {cb_state.index_buffer_binding.buffer, cb_state.index_buffer_binding.offset, + cb_state.index_buffer_binding.size}; + + validation_pipeline.BindShaderResources(gpuav, cb_state, shader_resources); + } + + { + VkPipeline pipeline_handle = + GetDrawValidationPipeline(gpuav, validation_pipeline.render_passes_to_pipeline, validation_pipeline.pipeline_layout, + validation_pipeline.shader_module, cb_state.activeRenderPass.get()->VkHandle(), loc); + if (pipeline_handle == VK_NULL_HANDLE) { + gpuav.InternalError(cb_state.VkHandle(), loc, "Could not find or create a pipeline."); + return; + } + + DispatchCmdBindPipeline(cb_state.VkHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_handle); + + // Dispatch as many draws as there are indices in index buffer. + // Each shader invocation will inspect one index, for all draw commands. + // Shader is in charge of performing validation only for indices within the supplied ranges. + + DispatchCmdDraw(cb_state.VkHandle(), max_indices_in_buffer, 1, 0, 0); + } + + CommandBuffer::ErrorLoggerFunc error_logger = + [loc, vuid_oob_vertex, draw_buffer, draw_buffer_offset, draw_cmds_byte_stride, smallest_vertex_buffer_binding, + index_buffer_binding = cb_state.index_buffer_binding, + max_indices_in_buffer](Validator &gpuav, const uint32_t *error_record, const LogObjectList &objlist) { + bool skip = false; + + using namespace glsl; + + switch (error_record[kHeaderErrorSubCodeOffset]) { + case kErrorSubCode_OobVertexBuffer: { + const uint32_t draw_i = error_record[kPreActionParamOffset_0]; + const uint32_t index_buffer_offset = error_record[kPreActionParamOffset_1]; + const int32_t vertex_offset = static_cast(error_record[kPreActionParamOffset_2]); + const uint32_t vertex_index = error_record[kPreActionParamOffset_3]; + const uint32_t index_buffer_value = static_cast(int32_t(vertex_index) - vertex_offset); + + gpuav.LogError( + vuid_oob_vertex, objlist, loc, + "Vertex index %" PRIu32 + " is not within the smallest bound vertex buffer. Computed from VkDrawIndexedIndirectCommand[%" PRIu32 + "], stored in %s\n" + "index_buffer[%" PRIu32 "] (%" PRIu32 ") + VkDrawIndexedIndirectCommand[%" PRIu32 "].vertexOffset (%" PRIi32 + ") = Vertex index %" PRIu32 + "\n" + + "Smallest vertex buffer binding info:\n" + "- Buffer: %s\n" + "- Binding: %" PRIu32 + "\n" + "- Binding offset: %" PRIu64 + "\n" + "- Binding size: %" PRIu64 + " bytes\n" + + "Index buffer binding info:\n" + "- Buffer: %s\n" + "- Index type: %s\n" + "- Binding offset: %" PRIu64 + "\n" + "- Binding size: %" PRIu64 " bytes (or %" PRIu32 + " %s)\n" + + "Supplied buffer parameters in indirect command: offset = %" PRIu64 ", stride = %" PRIu32 " bytes.", + // OOB vertex index info + vertex_index, draw_i, gpuav.FormatHandle(draw_buffer).c_str(), index_buffer_offset, index_buffer_value, + draw_i, vertex_offset, vertex_index, + + // Vertex buffer binding info + gpuav.FormatHandle(smallest_vertex_buffer_binding.binding_info.buffer).c_str(), + smallest_vertex_buffer_binding.binding, smallest_vertex_buffer_binding.binding_info.offset, + smallest_vertex_buffer_binding.binding_info.size, + + // Index buffer binding info + gpuav.FormatHandle(index_buffer_binding.buffer).c_str(), + string_VkIndexType(index_buffer_binding.index_type), index_buffer_binding.offset, index_buffer_binding.size, + max_indices_in_buffer, string_VkIndexType(index_buffer_binding.index_type), + + // VkDrawIndexedIndirectCommand info + draw_buffer_offset, draw_cmds_byte_stride); + break; + } + + default: + assert(false); + return skip; + } + + return skip; + }; + + cb_state.per_command_error_loggers.emplace_back(std::move(error_logger)); +} + +void DestroyRenderPassMappedResources(Validator &gpuav, VkRenderPass render_pass) { + // #ARNO_TODO: Come up with a lambda registration system + auto *first_instance_validation_pipeline = + gpuav.shared_resources_manager.TryGet>(); + + if (first_instance_validation_pipeline && first_instance_validation_pipeline->valid) { + auto pipeline = first_instance_validation_pipeline->render_passes_to_pipeline.pop(render_pass); + if (pipeline != first_instance_validation_pipeline->render_passes_to_pipeline.end()) { + DispatchDestroyPipeline(gpuav.device, pipeline->second, nullptr); + } + } + + auto *count_buffer_validation_pipeline = + gpuav.shared_resources_manager.TryGet>(); + + if (count_buffer_validation_pipeline && count_buffer_validation_pipeline->valid) { + auto pipeline = count_buffer_validation_pipeline->render_passes_to_pipeline.pop(render_pass); + if (pipeline != count_buffer_validation_pipeline->render_passes_to_pipeline.end()) { + DispatchDestroyPipeline(gpuav.device, pipeline->second, nullptr); + } + } + + auto *draw_mesh_validation_pipeline = gpuav.shared_resources_manager.TryGet>(); + + if (draw_mesh_validation_pipeline && draw_mesh_validation_pipeline->valid) { + auto pipeline = draw_mesh_validation_pipeline->render_passes_to_pipeline.pop(render_pass); + if (pipeline != draw_mesh_validation_pipeline->render_passes_to_pipeline.end()) { + DispatchDestroyPipeline(gpuav.device, pipeline->second, nullptr); + } + } + + auto *indexed_draw_validation_pipeline = + gpuav.shared_resources_manager.TryGet>(); + + if (indexed_draw_validation_pipeline && indexed_draw_validation_pipeline->valid) { + auto pipeline = indexed_draw_validation_pipeline->render_passes_to_pipeline.pop(render_pass); + if (pipeline != indexed_draw_validation_pipeline->render_passes_to_pipeline.end()) { + DispatchDestroyPipeline(gpuav.device, pipeline->second, nullptr); + } + } + + auto *draw_indexed_indirect_index_buffer_pipeline = + gpuav.shared_resources_manager.TryGet>(); + + if (draw_indexed_indirect_index_buffer_pipeline && draw_indexed_indirect_index_buffer_pipeline->valid) { + auto pipeline = draw_indexed_indirect_index_buffer_pipeline->render_passes_to_pipeline.pop(render_pass); + if (pipeline != draw_indexed_indirect_index_buffer_pipeline->render_passes_to_pipeline.end()) { + DispatchDestroyPipeline(gpuav.device, pipeline->second, nullptr); + } + } + + auto *draw_indexed_indirect_vertex_buffer_pipeline = + gpuav.shared_resources_manager.TryGet>(); + + if (draw_indexed_indirect_vertex_buffer_pipeline && draw_indexed_indirect_vertex_buffer_pipeline->valid) { + auto pipeline = draw_indexed_indirect_vertex_buffer_pipeline->render_passes_to_pipeline.pop(render_pass); + if (pipeline != draw_indexed_indirect_vertex_buffer_pipeline->render_passes_to_pipeline.end()) { + DispatchDestroyPipeline(gpuav.device, pipeline->second, nullptr); + } + } +} + +} // namespace draw } // namespace gpuav diff --git a/layers/gpu/cmd_validation/gpuav_draw.h b/layers/gpu/cmd_validation/gpuav_draw.h index 2a10ee20143..20241653462 100644 --- a/layers/gpu/cmd_validation/gpuav_draw.h +++ b/layers/gpu/cmd_validation/gpuav_draw.h @@ -19,15 +19,67 @@ #include +#include "vulkan/generated/error_location_helper.h" + struct Location; namespace gpuav { class Validator; +class CommandBuffer; + +namespace draw { void DestroyRenderPassMappedResources(Validator &gpuav, VkRenderPass render_pass); -void InsertIndirectDrawValidation(Validator &gpuav, const Location &loc, CommandBuffer &cb_state, VkBuffer indirect_buffer, - VkDeviceSize indirect_offset, uint32_t draw_count, VkBuffer count_buffer, - VkDeviceSize count_buffer_offset, uint32_t stride); +template +void FirstInstance(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, VkBuffer draw_buffer, + VkDeviceSize draw_buffer_offset, uint32_t draw_count, VkBuffer count_buffer, VkDeviceSize count_buffer_offset, + const char *vuid); + +template <> +void FirstInstance(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, VkBuffer draw_buffer, + VkDeviceSize draw_buffer_offset, uint32_t draw_count, VkBuffer count_buffer, + VkDeviceSize count_buffer_offset, const char *vuid); +template <> +void FirstInstance(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, + VkBuffer draw_buffer, VkDeviceSize draw_buffer_offset, uint32_t draw_count, + VkBuffer count_buffer, VkDeviceSize count_buffer_offset, const char *vuid); + +void FirstInstance(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, VkBuffer draw_buffer, + VkDeviceSize draw_buffer_offset, uint32_t draw_cmds_byte_stride, vvl::Struct draw_indirect_struct_name, + uint32_t first_instance_member_pos, uint32_t draw_count, VkBuffer count_buffer, VkDeviceSize count_buffer_offset, + const char *vuid); + +void CountBuffer(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, VkBuffer draw_buffer, + VkDeviceSize draw_buffer_offset, uint32_t draw_indirect_struct_byte_size, vvl::Struct draw_indirect_struct_name, + uint32_t draw_cmds_byte_stride, VkBuffer count_buffer, VkDeviceSize count_buffer_offset, + const char *vuid_draw_buffer_size, const char *vuid_max_draw_count); + +struct DrawMeshIndirectVuids { + const char *task_group_count_exceeds_max_x{}; + const char *task_group_count_exceeds_max_y{}; + const char *task_group_count_exceeds_max_z{}; + const char *task_group_count_exceeds_max_total{}; + const char *mesh_group_count_exceeds_max_x{}; + const char *mesh_group_count_exceeds_max_y{}; + const char *mesh_group_count_exceeds_max_z{}; + const char *mesh_group_count_exceeds_max_total{}; +}; + +void DrawMeshIndirect(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, VkBuffer draw_buffer, + VkDeviceSize draw_buffer_offset, uint32_t draw_cmds_byte_stride, VkBuffer count_buffer, + VkDeviceSize count_buffer_offset, uint32_t draw_count, const DrawMeshIndirectVuids &vuids); + +void DrawIndexed(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, uint32_t index_count, uint32_t first_index, + uint32_t vertex_offset, const char *vuid_oob_vertex); + +void DrawIndexedIndirectIndexBuffer(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, VkBuffer draw_buffer, + VkDeviceSize draw_buffer_offset, uint32_t draw_cmds_byte_stride, uint32_t draw_count, + VkBuffer count_buffer, VkDeviceSize count_buffer_offset, const char *vuid_oob_index); + +void DrawIndexedIndirectVertexBuffer(Validator &gpuav, CommandBuffer &cb_state, const Location &loc, VkBuffer draw_buffer, + VkDeviceSize draw_buffer_offset, uint32_t draw_cmds_byte_stride, uint32_t draw_count, + VkBuffer count_buffer, VkDeviceSize count_buffer_offset, const char *vuid_oob_vertex); +} // namespace draw } // namespace gpuav diff --git a/layers/gpu/cmd_validation/gpuav_trace_rays.cpp b/layers/gpu/cmd_validation/gpuav_trace_rays.cpp index b5ea7008d44..32166484369 100644 --- a/layers/gpu/cmd_validation/gpuav_trace_rays.cpp +++ b/layers/gpu/cmd_validation/gpuav_trace_rays.cpp @@ -215,7 +215,7 @@ void InsertIndirectTraceRaysValidation(Validator &gpuav, const Location &loc, Co } // Save current ray tracing pipeline state - RestorablePipelineState restorable_state(cb_state, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR); + RestorablePipelineState restorable_state(gpuav, cb_state, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR); // Push info needed for validation: // - the device address indirect data is read from @@ -235,9 +235,9 @@ void InsertIndirectTraceRaysValidation(Validator &gpuav, const Location &loc, Co push_constants[4] = static_cast(std::min(ray_query_dimension_max_depth, vvl::kU32Max)); DispatchCmdBindPipeline(cb_state.VkHandle(), VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, shared_trace_rays_resources.pipeline); - BindValidationCmdsCommonDescSet(gpuav, cb_state, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, - shared_trace_rays_resources.pipeline_layout, cb_state.trace_rays_index, - static_cast(cb_state.per_command_error_loggers.size())); + BindErrorLoggingDescriptorSet(gpuav, cb_state, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, + shared_trace_rays_resources.pipeline_layout, cb_state.trace_rays_index, + static_cast(cb_state.per_command_error_loggers.size())); DispatchCmdPushConstants(cb_state.VkHandle(), shared_trace_rays_resources.pipeline_layout, VK_SHADER_STAGE_RAYGEN_BIT_KHR, 0, sizeof(push_constants), push_constants); VkStridedDeviceAddressRegionKHR ray_gen_sbt{}; diff --git a/layers/gpu/cmd_validation/gpuav_trace_rays.h b/layers/gpu/cmd_validation/gpuav_trace_rays.h index 78436c2c5e7..7e056a03185 100644 --- a/layers/gpu/cmd_validation/gpuav_trace_rays.h +++ b/layers/gpu/cmd_validation/gpuav_trace_rays.h @@ -24,8 +24,6 @@ struct Location; namespace gpuav { class Validator; -void DestroyRenderPassMappedResources(Validator &gpuav, VkRenderPass render_pass); - void InsertIndirectTraceRaysValidation(Validator &gpuav, const Location &loc, CommandBuffer &cb_state, VkDeviceAddress indirect_data_address); diff --git a/layers/gpu/core/gpu_settings.h b/layers/gpu/core/gpu_settings.h index 978264ab06d..cdb7fb6ad4e 100644 --- a/layers/gpu/core/gpu_settings.h +++ b/layers/gpu/core/gpu_settings.h @@ -30,6 +30,7 @@ struct GpuAVSettings { bool validate_indirect_dispatches_buffers = true; bool validate_indirect_trace_rays_buffers = true; bool validate_buffer_copies = true; + bool validate_index_buffers = true; bool vma_linear_output = true; @@ -62,13 +63,14 @@ struct GpuAVSettings { } bool IsBufferValidationEnabled() const { return validate_indirect_draws_buffers || validate_indirect_dispatches_buffers || validate_indirect_trace_rays_buffers || - validate_buffer_copies; + validate_buffer_copies || validate_index_buffers; } void SetBufferValidationEnabled(bool enabled) { validate_indirect_draws_buffers = enabled; validate_indirect_dispatches_buffers = enabled; validate_indirect_trace_rays_buffers = enabled; validate_buffer_copies = enabled; + validate_index_buffers = enabled; } }; diff --git a/layers/gpu/core/gpuav.h b/layers/gpu/core/gpuav.h index edc547aa5cb..3d01ac2dc39 100644 --- a/layers/gpu/core/gpuav.h +++ b/layers/gpu/core/gpuav.h @@ -324,7 +324,7 @@ class Validator : public gpu::GpuShaderInstrumentor { public: std::optional desc_heap_{}; // optional only to defer construction - gpu::SharedResourcesManager shared_resources_manager; + gpu::SharedResourcesCache shared_resources_manager; private: std::string instrumented_shader_cache_path_{}; diff --git a/layers/gpu/core/gpuav_record.cpp b/layers/gpu/core/gpuav_record.cpp index 743bc77ca2f..6a8ce8a5fa4 100644 --- a/layers/gpu/core/gpuav_record.cpp +++ b/layers/gpu/core/gpuav_record.cpp @@ -48,10 +48,15 @@ void Validator::PreCallRecordCreateBuffer(VkDevice device, const VkBufferCreateI // Indirect buffers will require validation shader to bind the indirect buffers as a storage buffer. if (gpuav_settings.IsBufferValidationEnabled() && - chassis_state.modified_create_info.usage & VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT) { + (chassis_state.modified_create_info.usage & (VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT))) { chassis_state.modified_create_info.usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; } + // Align index buffer size to 4: validation shader reads DWORDS + if (gpuav_settings.IsBufferValidationEnabled()) { + chassis_state.modified_create_info.size = Align(chassis_state.modified_create_info.size, 4); + } + BaseClass::PreCallRecordCreateBuffer(device, pCreateInfo, pAllocator, pBuffer, record_obj, chassis_state); } @@ -83,7 +88,7 @@ void Validator::PostCallRecordGetPhysicalDeviceProperties2(VkPhysicalDevice phys void Validator::PreCallRecordDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator, const RecordObject &record_obj) { - DestroyRenderPassMappedResources(*this, renderPass); + draw::DestroyRenderPassMappedResources(*this, renderPass); BaseClass::PreCallRecordDestroyRenderPass(device, renderPass, pAllocator, record_obj); } @@ -337,6 +342,9 @@ void Validator::PreCallRecordCmdDrawIndexed(VkCommandBuffer commandBuffer, uint3 InternalError(commandBuffer, record_obj.location, "Unrecognized command buffer."); return; } + + draw::DrawIndexed(*this, *cb_state, record_obj.location, indexCount, firstIndex, vertexOffset, + "VUID-vkCmdDrawIndexed-None-02721"); SetupShaderInstrumentationResources(*this, *cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS, record_obj.location); } @@ -367,7 +375,15 @@ void Validator::PreCallRecordCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBu return; } - InsertIndirectDrawValidation(*this, record_obj.location, *cb_state, buffer, offset, count, VK_NULL_HANDLE, 0, stride); + auto indirect_buffer_state = Get(buffer); + if (!indirect_buffer_state) { + InternalError(commandBuffer, record_obj.location, "buffer must be a valid VkBuffer handle"); + return; + } + + draw::FirstInstance(*this, *cb_state, record_obj.location, buffer, offset, count, VK_NULL_HANDLE, 0, + "VUID-VkDrawIndirectCommand-firstInstance-00501"); + SetupShaderInstrumentationResources(*this, *cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS, record_obj.location); } @@ -381,7 +397,13 @@ void Validator::PreCallRecordCmdDrawIndexedIndirect(VkCommandBuffer commandBuffe return; } - InsertIndirectDrawValidation(*this, record_obj.location, *cb_state, buffer, offset, count, VK_NULL_HANDLE, 0, stride); + draw::DrawIndexedIndirectIndexBuffer(*this, *cb_state, record_obj.location, buffer, offset, stride, count, VK_NULL_HANDLE, 0, + "VUID-VkDrawIndexedIndirectCommand-robustBufferAccess2-08798"); + draw::DrawIndexedIndirectVertexBuffer(*this, *cb_state, record_obj.location, buffer, offset, stride, count, VK_NULL_HANDLE, 0, + "VUID-vkCmdDrawIndexedIndirect-None-02721"); + draw::FirstInstance(*this, *cb_state, record_obj.location, buffer, offset, count, + VK_NULL_HANDLE, 0, "VUID-VkDrawIndexedIndirectCommand-firstInstance-00554"); + SetupShaderInstrumentationResources(*this, *cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS, record_obj.location); } @@ -403,8 +425,18 @@ void Validator::PreCallRecordCmdDrawIndirectCount(VkCommandBuffer commandBuffer, InternalError(commandBuffer, record_obj.location, "Unrecognized command buffer."); return; } - InsertIndirectDrawValidation(*this, record_obj.location, *cb_state, buffer, offset, maxDrawCount, countBuffer, - countBufferOffset, stride); + + auto indirect_buffer_state = Get(buffer); + if (!indirect_buffer_state) { + InternalError(commandBuffer, record_obj.location, "buffer must be a valid VkBuffer handle"); + return; + } + + draw::CountBuffer(*this, *cb_state, record_obj.location, buffer, offset, sizeof(VkDrawIndirectCommand), + vvl::Struct::VkDrawIndirectCommand, stride, countBuffer, countBufferOffset, + "VUID-vkCmdDrawIndirectCount-countBuffer-03122", "VUID-vkCmdDrawIndirectCount-countBuffer-02717"); + draw::FirstInstance(*this, *cb_state, record_obj.location, buffer, offset, maxDrawCount, countBuffer, + countBufferOffset, "VUID-VkDrawIndirectCommand-firstInstance-00501"); SetupShaderInstrumentationResources(*this, *cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS, record_obj.location); } @@ -441,8 +473,19 @@ void Validator::PreCallRecordCmdDrawIndexedIndirectCount(VkCommandBuffer command InternalError(commandBuffer, record_obj.location, "Unrecognized command buffer."); return; } - InsertIndirectDrawValidation(*this, record_obj.location, *cb_state, buffer, offset, maxDrawCount, countBuffer, - countBufferOffset, stride); + draw::CountBuffer(*this, *cb_state, record_obj.location, buffer, offset, sizeof(VkDrawIndexedIndirectCommand), + vvl::Struct::VkDrawIndexedIndirectCommand, stride, countBuffer, countBufferOffset, + "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-03154", + "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02717"); + draw::FirstInstance(*this, *cb_state, record_obj.location, buffer, offset, maxDrawCount, + countBuffer, countBufferOffset, + "VUID-VkDrawIndexedIndirectCommand-firstInstance-00554"); + + draw::DrawIndexedIndirectIndexBuffer(*this, *cb_state, record_obj.location, buffer, offset, stride, maxDrawCount, countBuffer, + countBufferOffset, "VUID-VkDrawIndexedIndirectCommand-robustBufferAccess2-08798"); + draw::DrawIndexedIndirectVertexBuffer(*this, *cb_state, record_obj.location, buffer, offset, stride, maxDrawCount, + countBuffer, countBufferOffset, "VUID-VkDrawIndexedIndirectCommand-None-00552"); + SetupShaderInstrumentationResources(*this, *cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS, record_obj.location); } @@ -466,7 +509,12 @@ void Validator::PreCallRecordCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandB InternalError(commandBuffer, record_obj.location, "Unrecognized command buffer."); return; } - InsertIndirectDrawValidation(*this, record_obj.location, *cb_state, buffer, offset, drawCount, VK_NULL_HANDLE, 0, stride); + auto indirect_buffer_state = Get(buffer); + if (!indirect_buffer_state) { + InternalError(commandBuffer, record_obj.location, "buffer must be a valid VkBuffer handle"); + return; + } + SetupShaderInstrumentationResources(*this, *cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS, record_obj.location); } @@ -482,8 +530,16 @@ void Validator::PreCallRecordCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer com InternalError(commandBuffer, record_obj.location, "Unrecognized command buffer."); return; } - InsertIndirectDrawValidation(*this, record_obj.location, *cb_state, buffer, offset, maxDrawCount, countBuffer, - countBufferOffset, stride); + auto indirect_buffer_state = Get(buffer); + if (!indirect_buffer_state) { + InternalError(commandBuffer, record_obj.location, "buffer must be a valid VkBuffer handle"); + return; + } + + draw::CountBuffer(*this, *cb_state, record_obj.location, buffer, offset, sizeof(VkDrawMeshTasksIndirectCommandNV), + vvl::Struct::VkDrawMeshTasksIndirectCommandNV, stride, countBuffer, countBufferOffset, + "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02192", + "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02717"); SetupShaderInstrumentationResources(*this, *cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS, record_obj.location); } @@ -507,7 +563,18 @@ void Validator::PreCallRecordCmdDrawMeshTasksIndirectEXT(VkCommandBuffer command InternalError(commandBuffer, record_obj.location, "Unrecognized command buffer."); return; } - InsertIndirectDrawValidation(*this, record_obj.location, *cb_state, buffer, offset, drawCount, VK_NULL_HANDLE, 0, stride); + + draw::DrawMeshIndirectVuids vuids; + vuids.task_group_count_exceeds_max_x = "VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07322"; + vuids.task_group_count_exceeds_max_y = "VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07323"; + vuids.task_group_count_exceeds_max_z = "VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07324"; + vuids.task_group_count_exceeds_max_total = "VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07325"; + vuids.mesh_group_count_exceeds_max_x = "VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07326"; + vuids.mesh_group_count_exceeds_max_y = "VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07327"; + vuids.mesh_group_count_exceeds_max_z = "VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07328"; + vuids.mesh_group_count_exceeds_max_total = "VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07329"; + draw::DrawMeshIndirect(*this, *cb_state, record_obj.location, buffer, offset, stride, VK_NULL_HANDLE, 0, drawCount, vuids); + SetupShaderInstrumentationResources(*this, *cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS, record_obj.location); } @@ -523,8 +590,29 @@ void Validator::PreCallRecordCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer co InternalError(commandBuffer, record_obj.location, "Unrecognized command buffer."); return; } - InsertIndirectDrawValidation(*this, record_obj.location, *cb_state, buffer, offset, maxDrawCount, countBuffer, - countBufferOffset, stride); + auto indirect_buffer_state = Get(buffer); + if (!indirect_buffer_state) { + InternalError(commandBuffer, record_obj.location, "buffer must be a valid VkBuffer handle"); + return; + } + + draw::DrawMeshIndirectVuids vuids; + vuids.task_group_count_exceeds_max_x = "VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07322"; + vuids.task_group_count_exceeds_max_y = "VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07323"; + vuids.task_group_count_exceeds_max_z = "VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07324"; + vuids.task_group_count_exceeds_max_total = "VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07325"; + vuids.mesh_group_count_exceeds_max_x = "VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07326"; + vuids.mesh_group_count_exceeds_max_y = "VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07327"; + vuids.mesh_group_count_exceeds_max_z = "VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07328"; + vuids.mesh_group_count_exceeds_max_total = "VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07329"; + draw::DrawMeshIndirect(*this, *cb_state, record_obj.location, buffer, offset, stride, countBuffer, countBufferOffset, + maxDrawCount, vuids); + + draw::CountBuffer(*this, *cb_state, record_obj.location, buffer, offset, sizeof(VkDrawMeshTasksIndirectCommandEXT), + vvl::Struct::VkDrawMeshTasksIndirectCommandEXT, stride, countBuffer, countBufferOffset, + "VUID-vkCmdDrawMeshTasksIndirectCountEXT-countBuffer-07099", + "VUID-vkCmdDrawMeshTasksIndirectCountEXT-countBuffer-02717"); + SetupShaderInstrumentationResources(*this, *cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS, record_obj.location); } diff --git a/layers/gpu/core/gpuav_setup.cpp b/layers/gpu/core/gpuav_setup.cpp index f8ffd5f699c..ddc9e8d47b8 100644 --- a/layers/gpu/core/gpuav_setup.cpp +++ b/layers/gpu/core/gpuav_setup.cpp @@ -78,10 +78,10 @@ void Validator::PreCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const // In PreCallRecord this is all about trying to turn on as many feature/extension as possible on behalf of the app - auto add_missing_features = [this, &record_obj, modified_create_info]() { + auto add_bda_feature = [this, &record_obj, modified_create_info]() { // Add buffer device address feature if (auto *bda_features = const_cast( - vku::FindStructInPNextChain(modified_create_info))) { + vku::FindStructInPNextChain(modified_create_info->pNext))) { InternalWarning(device, record_obj.location, "Forcing VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddress to VK_TRUE"); bda_features->bufferDeviceAddress = VK_TRUE; @@ -104,13 +104,31 @@ void Validator::PreCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const features12->bufferDeviceAddress = VK_TRUE; } } else { - add_missing_features(); + add_bda_feature(); } } else if (api_version == VK_API_VERSION_1_1) { // Add our new extensions (will only add if found) const std::string_view bda_ext{"VK_KHR_buffer_device_address"}; vku::AddExtension(*modified_create_info, bda_ext.data()); - add_missing_features(); + add_bda_feature(); + } + + // shaderInt64 + VkPhysicalDeviceFeatures physical_device_features{}; + DispatchGetPhysicalDeviceFeatures(physicalDevice, &physical_device_features); + if (physical_device_features.shaderInt64) { + if (auto enabled_features = const_cast(modified_create_info->pEnabledFeatures)) { + enabled_features->shaderInt64 = VK_TRUE; + } else if (auto *features = const_cast(vku::FindStructInPNextChain(modified_create_info->pNext))) { + features->features.shaderInt64 = VK_TRUE; + } else { + // Need to add a VkPhysicalDeviceFeatures pointer + enabled_features = new VkPhysicalDeviceFeatures; + enabled_features->shaderInt64 = VK_TRUE; + modified_create_info->pEnabledFeatures = enabled_features; + } + } else { + InternalWarning(device, record_obj.location, "shaderInt64 feature not available, countBuffer (as seen in commands like vkCmdDrawIndexedIndirectCount) validation will not be performed."); } } diff --git a/layers/gpu/error_message/gpuav_vuids.cpp b/layers/gpu/error_message/gpuav_vuids.cpp index 140b3a3d1ed..13f6735daab 100644 --- a/layers/gpu/error_message/gpuav_vuids.cpp +++ b/layers/gpu/error_message/gpuav_vuids.cpp @@ -46,6 +46,9 @@ struct GpuVuidsCmdDrawIndexed : GpuVuid { uniform_access_oob_08612 = "VUID-vkCmdDrawIndexed-None-08612"; storage_access_oob_08613 = "VUID-vkCmdDrawIndexed-None-08613"; invalid_descriptor = "VUID-vkCmdDrawIndexed-None-08114"; + // This should be detected on the host by core validation but just in case... + index_buffer_size = "VUID-vkCmdDrawIndexedEXT-robustBufferAccess2-08798"; + vertex_index_oob = "VUID-vkCmdDrawIndexed-None-02721"; } }; @@ -56,6 +59,8 @@ struct GpuVuidsCmdDrawMultiIndexedEXT : GpuVuid { uniform_access_oob_08612 = "VUID-vkCmdDrawMultiIndexedEXT-None-08612"; storage_access_oob_08613 = "VUID-vkCmdDrawMultiIndexedEXT-None-08613"; invalid_descriptor = "VUID-vkCmdDrawMultiIndexedEXT-None-08114"; + index_buffer_size = "VUID-vkCmdDrawMultiIndexedEXT-robustBufferAccess2-08798"; + vertex_index_oob = "VUID-vkCmdDrawMultiIndexedEXT-None-02721"; } }; @@ -78,6 +83,8 @@ struct GpuVuidsCmdDrawIndexedIndirect : GpuVuid { storage_access_oob_08613 = "VUID-vkCmdDrawIndexedIndirect-None-08613"; invalid_descriptor = "VUID-vkCmdDrawIndexedIndirect-None-08114"; first_instance_not_zero = "VUID-VkDrawIndexedIndirectCommand-firstInstance-00554"; + index_buffer_size = "VUID-vkCmdDrawIndexedIndirect-robustBufferAccess2-08798"; + vertex_index_oob = "VUID-vkCmdDrawIndexedIndirect-None-02721"; } }; @@ -128,6 +135,8 @@ struct GpuVuidsCmdDrawIndexedIndirectCount : GpuVuid { count_exceeds_bufsize_1 = "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-03153"; count_exceeds_bufsize = "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-03154"; count_exceeds_device_limit = "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02717"; + index_buffer_size = "VUID-vkCmdDrawIndexedIndirectCount-robustBufferAccess2-08798"; + vertex_index_oob = "VUID-vkCmdDrawIndexedIndirectCount-None-02721"; } }; diff --git a/layers/gpu/error_message/gpuav_vuids.h b/layers/gpu/error_message/gpuav_vuids.h index 527aa9bbc10..a8bd10cba4a 100644 --- a/layers/gpu/error_message/gpuav_vuids.h +++ b/layers/gpu/error_message/gpuav_vuids.h @@ -46,6 +46,8 @@ struct GpuVuid { const char* trace_rays_width_exceeds_device_limit = kVUIDUndefined; const char* trace_rays_height_exceeds_device_limit = kVUIDUndefined; const char* trace_rays_depth_exceeds_device_limit = kVUIDUndefined; + const char* index_buffer_size = kVUIDUndefined; + const char* vertex_index_oob = kVUIDUndefined; }; // Getter function to provide kVUIDUndefined in case an invalid function is passed in diff --git a/layers/gpu/instrumentation/gpu_shader_instrumentor.h b/layers/gpu/instrumentation/gpu_shader_instrumentor.h index f49e2126c46..88895f508be 100644 --- a/layers/gpu/instrumentation/gpu_shader_instrumentor.h +++ b/layers/gpu/instrumentation/gpu_shader_instrumentor.h @@ -228,7 +228,7 @@ class GpuShaderInstrumentor : public ValidationStateTracker { std::vector instrumentation_bindings_; SpirvCache instrumented_shaders_cache_; DeviceMemoryBlock indices_buffer_{}; - unsigned int indices_buffer_alignment_ = 0; + uint32_t indices_buffer_alignment_ = 0; // DebugPrintf takes the first available slot in the set uint32_t debug_printf_binding_slot_ = 0; diff --git a/layers/gpu/resources/gpu_resources.cpp b/layers/gpu/resources/gpu_resources.cpp index 3b2a9f9c031..acf0d4f1835 100644 --- a/layers/gpu/resources/gpu_resources.cpp +++ b/layers/gpu/resources/gpu_resources.cpp @@ -135,7 +135,7 @@ void DescriptorSetManager::PutBackDescriptorSet(VkDescriptorPool desc_pool, VkDe return; } -void SharedResourcesManager::Clear() { +void SharedResourcesCache::Clear() { for (auto &[key, value] : shared_validation_resources_map_) { auto &[object, destructor] = value; destructor(object); diff --git a/layers/gpu/resources/gpu_resources.h b/layers/gpu/resources/gpu_resources.h index 92a93f07470..c208c0deb84 100644 --- a/layers/gpu/resources/gpu_resources.h +++ b/layers/gpu/resources/gpu_resources.h @@ -72,7 +72,8 @@ class GpuResourcesManager { std::vector mem_blocks_; }; -class SharedResourcesManager { +// Cache a single object of type T. Key is *only* based on typeid(T) +class SharedResourcesCache { public: template T *TryGet() { @@ -84,6 +85,10 @@ class SharedResourcesManager { return t; } + // First call to Get will create the object, subsequent calls will retrieve the cached entry. + // /!\ The cache key is only based on the type T, not on the passed parameters + // => Successive calls to Get with different parameters will NOT give different objects, + // only the entry cached upon the first call to Get will be retrieved template T &Get(ConstructorTypes &&...args) { T *t = TryGet(); @@ -113,4 +118,9 @@ class SharedResourcesManager { shared_validation_resources_map_; }; +struct BoundStorageBuffer { + uint32_t binding = vvl::kU32Max; + VkDescriptorBufferInfo info{VK_NULL_HANDLE, vvl::kU64Max, 0}; +}; + } // namespace gpu diff --git a/layers/gpu/resources/gpuav_subclasses.cpp b/layers/gpu/resources/gpuav_subclasses.cpp index 29937fe2552..8f1b26cc3a3 100644 --- a/layers/gpu/resources/gpuav_subclasses.cpp +++ b/layers/gpu/resources/gpuav_subclasses.cpp @@ -438,6 +438,124 @@ void CommandBuffer::ClearCmdErrorsCountsBuffer(const Location &loc) const { vmaUnmapMemory(gpuav->vma_allocator_, cmd_errors_counts_buffer_.allocation); } +void CommandBuffer::RestoreDynamicStates(const Validator &gpuav_) { + for (int dynamic_state = 0; dynamic_state < CB_DYNAMIC_STATE_STATUS_NUM; ++dynamic_state) { + if (!dynamic_state_status.cb[dynamic_state]) { + continue; + } + + switch (dynamic_state) { + case CB_DYNAMIC_STATE_VIEWPORT: { + DispatchCmdSetViewport(VkHandle(), dynamic_state_value.first_viewport, + uint32_t(dynamic_state_value.viewports.size()), dynamic_state_value.viewports.data()); + } break; + case CB_DYNAMIC_STATE_DEPTH_BIAS: { + DispatchCmdSetDepthBias(VkHandle(), dynamic_state_value.depth_bias_constant_factor, + dynamic_state_value.depth_bias_clamp, dynamic_state_value.depth_bias_slope_factor); + } break; + case CB_DYNAMIC_STATE_BLEND_CONSTANTS: { + DispatchCmdSetBlendConstants(VkHandle(), dynamic_state_value.blend_constants.data()); + } break; + case CB_DYNAMIC_STATE_DEPTH_TEST_ENABLE: { + if (IsExtEnabledByCreateinfo(gpuav_.device_extensions.vk_ext_extended_dynamic_state)) { + DispatchCmdSetDepthTestEnableEXT(VkHandle(), dynamic_state_value.depth_test_enable); + } else { + DispatchCmdSetDepthTestEnable(VkHandle(), dynamic_state_value.depth_test_enable); + } + } break; + case CB_DYNAMIC_STATE_DEPTH_WRITE_ENABLE: { + if (IsExtEnabledByCreateinfo(gpuav_.device_extensions.vk_ext_extended_dynamic_state)) { + DispatchCmdSetDepthWriteEnableEXT(VkHandle(), dynamic_state_value.depth_write_enable); + } else { + DispatchCmdSetDepthWriteEnable(VkHandle(), dynamic_state_value.depth_write_enable); + } + } break; + case CB_DYNAMIC_STATE_DEPTH_BIAS_ENABLE: { + if (IsExtEnabledByCreateinfo(gpuav_.device_extensions.vk_ext_extended_dynamic_state2)) { + DispatchCmdSetDepthBiasEnableEXT(VkHandle(), dynamic_state_value.depth_bias_enable); + } else { + DispatchCmdSetDepthBiasEnable(VkHandle(), dynamic_state_value.depth_bias_enable); + } + } break; + case CB_DYNAMIC_STATE_DEPTH_COMPARE_OP: { + if (IsExtEnabledByCreateinfo(gpuav_.device_extensions.vk_ext_extended_dynamic_state)) { + DispatchCmdSetDepthCompareOpEXT(VkHandle(), dynamic_state_value.depth_compare_op); + } else { + DispatchCmdSetDepthCompareOp(VkHandle(), dynamic_state_value.depth_compare_op); + } + } break; + case CB_DYNAMIC_STATE_VERTEX_INPUT_EXT: { + std::vector vertex_binding_descs; + std::vector vertex_attribute_descs; + for (const auto &[binding_unused_, vertex_binding_state] : dynamic_state_value.vertex_bindings) { + // Given how dynamic_state_value.vertex_bindings is filled, no need to filter vertex binding descriptions before + // adding them to the list: + // they are not duplicated, and they are all here. + vertex_binding_descs.push_back(*vertex_binding_state.desc.ptr()); + + for (const auto &[location_unused_2, vertex_attribute_state] : vertex_binding_state.locations) { + auto has_same_vertex_attribute = + [lhs = vertex_attribute_state.desc.ptr()](const VkVertexInputAttributeDescription2EXT &rhs) { + return lhs->sType == rhs.sType && lhs->pNext == rhs.pNext && lhs->location == rhs.location && + lhs->binding == rhs.binding && lhs->format == rhs.format && lhs->offset == rhs.offset; + }; + if (std::find_if(vertex_attribute_descs.begin(), vertex_attribute_descs.end(), has_same_vertex_attribute) == + vertex_attribute_descs.end()) { + vertex_attribute_descs.push_back(*vertex_attribute_state.desc.ptr()); + } + } + } + DispatchCmdSetVertexInputEXT(VkHandle(), uint32_t(vertex_attribute_descs.size()), vertex_binding_descs.data(), + uint32_t(vertex_attribute_descs.size()), vertex_attribute_descs.data()); + } break; + + case CB_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE: { + if (IsExtEnabledByCreateinfo(gpuav_.device_extensions.vk_ext_extended_dynamic_state)) { + DispatchCmdSetPrimitiveRestartEnableEXT(VkHandle(), dynamic_state_value.primitive_restart_enable); + } else { + DispatchCmdSetPrimitiveRestartEnable(VkHandle(), dynamic_state_value.primitive_restart_enable); + } + } break; + case CB_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY: { + if (IsExtEnabledByCreateinfo(gpuav_.device_extensions.vk_ext_extended_dynamic_state)) { + DispatchCmdSetPrimitiveTopologyEXT(VkHandle(), dynamic_state_value.primitive_topology); + } else { + DispatchCmdSetPrimitiveTopology(VkHandle(), dynamic_state_value.primitive_topology); + } + } break; + case CB_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT: { + DispatchCmdSetDepthClampEnableEXT(VkHandle(), dynamic_state_value.depth_clamp_enable); + } break; + case CB_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE: { + if (IsExtEnabledByCreateinfo(gpuav_.device_extensions.vk_ext_extended_dynamic_state2)) { + DispatchCmdSetRasterizerDiscardEnableEXT(VkHandle(), dynamic_state_value.rasterizer_discard_enable); + } else { + DispatchCmdSetRasterizerDiscardEnable(VkHandle(), dynamic_state_value.rasterizer_discard_enable); + } + } break; + case CB_DYNAMIC_STATE_POLYGON_MODE_EXT: { + DispatchCmdSetPolygonModeEXT(VkHandle(), dynamic_state_value.polygon_mode); + } break; + case CB_DYNAMIC_STATE_CULL_MODE: { + if (IsExtEnabledByCreateinfo(gpuav_.device_extensions.vk_ext_extended_dynamic_state)) { + DispatchCmdSetCullModeEXT(VkHandle(), dynamic_state_value.cull_mode); + } else { + DispatchCmdSetCullMode(VkHandle(), dynamic_state_value.cull_mode); + } + } break; + case CB_DYNAMIC_STATE_FRONT_FACE: { + if (IsExtEnabledByCreateinfo(gpuav_.device_extensions.vk_ext_extended_dynamic_state)) { + DispatchCmdSetFrontFaceEXT(VkHandle(), dynamic_state_value.front_face); + } else { + DispatchCmdSetFrontFace(VkHandle(), dynamic_state_value.front_face); + } + } break; + default: + break; + } + } +} + bool CommandBuffer::PreProcess(const Location &loc) { auto gpuav = static_cast(&dev_data); diff --git a/layers/gpu/resources/gpuav_subclasses.h b/layers/gpu/resources/gpuav_subclasses.h index b4aae93f225..2fe56859b40 100644 --- a/layers/gpu/resources/gpuav_subclasses.h +++ b/layers/gpu/resources/gpuav_subclasses.h @@ -88,13 +88,16 @@ class CommandBuffer : public gpu_tracker::CommandBuffer { void ClearCmdErrorsCountsBuffer(const Location &loc) const; + void RestoreDynamicStates(const Validator &gpuav); + void Destroy() final; void Reset(const Location &loc) final; gpu::GpuResourcesManager gpu_resources_manager; // Using stdext::inplace_function over std::function to allocate memory in place using ErrorLoggerFunc = - stdext::inplace_function; + stdext::inplace_function; std::vector per_command_error_loggers; private: diff --git a/layers/gpu/shaders/cmd_validation/common.h b/layers/gpu/shaders/cmd_validation/common.h index 865743a53fa..3e2dc55d9f1 100644 --- a/layers/gpu/shaders/cmd_validation/common.h +++ b/layers/gpu/shaders/cmd_validation/common.h @@ -23,9 +23,11 @@ layout(set = kDiagCommonDescriptorSet, binding = kBindingDiagErrorBuffer) buffer uint errors_buffer[]; }; -layout(set = kDiagCommonDescriptorSet, binding = kBindingDiagActionIndex) buffer ActionIndexBuffer { uint action_index[]; }; +layout(set = kDiagCommonDescriptorSet, binding = kBindingDiagActionIndex) readonly buffer ActionIndexBuffer { + uint action_index[]; +}; -layout(set = kDiagCommonDescriptorSet, binding = kBindingDiagCmdResourceIndex) buffer ResourceIndexBuffer { +layout(set = kDiagCommonDescriptorSet, binding = kBindingDiagCmdResourceIndex) readonly buffer ResourceIndexBuffer { uint resource_index[]; }; @@ -39,7 +41,7 @@ bool MaxCmdErrorsCountReached() { return cmd_errors_count >= kMaxErrorsPerCmd; } -void GpuavLogError(uint error_group, uint error_sub_code, uint param_0, uint param_1) { +void GpuavLogError4(uint error_group, uint error_sub_code, uint param_0, uint param_1, uint param_2, uint param_3) { if (MaxCmdErrorsCountReached()) return; uint vo_idx = atomicAdd(errors_count, kErrorRecordSize); @@ -54,4 +56,10 @@ void GpuavLogError(uint error_group, uint error_sub_code, uint param_0, uint par errors_buffer[vo_idx + kPreActionParamOffset_0] = param_0; errors_buffer[vo_idx + kPreActionParamOffset_1] = param_1; + errors_buffer[vo_idx + kPreActionParamOffset_2] = param_2; + errors_buffer[vo_idx + kPreActionParamOffset_3] = param_3; +} + +void GpuavLogError2(uint error_group, uint error_sub_code, uint param_0, uint param_1) { + GpuavLogError4(error_group, error_sub_code, param_0, param_1, 0, 0); } diff --git a/layers/gpu/shaders/cmd_validation/copy_buffer_to_image.comp b/layers/gpu/shaders/cmd_validation/copy_buffer_to_image.comp index 9646e615fdf..f90f91aa2e9 100644 --- a/layers/gpu/shaders/cmd_validation/copy_buffer_to_image.comp +++ b/layers/gpu/shaders/cmd_validation/copy_buffer_to_image.comp @@ -109,7 +109,7 @@ void main() { Texel texel = SearchOobDepthValue(tid, region_i); if (texel.value < 0 || texel.value > 1) { - GpuavLogError(kErrorGroupGpuCopyBufferToImage, kErrorSubCodePreCopyBufferToImageBufferTexel, texel.byte_offset, 0); + GpuavLogError2(kErrorGroupGpuCopyBufferToImage, kErrorSubCodePreCopyBufferToImageBufferTexel, texel.byte_offset, 0); } } } diff --git a/layers/gpu/shaders/cmd_validation/count_buffer.vert b/layers/gpu/shaders/cmd_validation/count_buffer.vert new file mode 100644 index 00000000000..36dfda21424 --- /dev/null +++ b/layers/gpu/shaders/cmd_validation/count_buffer.vert @@ -0,0 +1,44 @@ +// Copyright (c) 2021-2024 The Khronos Group Inc. +// Copyright (c) 2021-2024 Valve Corporation +// Copyright (c) 2021-2024 LunarG, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#version 450 +#extension GL_GOOGLE_include_directive : enable + +#include "common.h" +#include "draw_push_data.h" + +layout(push_constant) +uniform PushConstants { + CountBufferPushData pc; +}; + +layout(set = kDiagPerCmdDescriptorSet, binding = kPreDrawBinding_CountBuffer) +readonly buffer CountBuffer { + uint draw_count; +}; + +void main() { + gl_PointSize = 1.0; + + if (draw_count == 0) return; + + const uint64_t draw_buffer_max_read_offset = pc.draw_cmds_byte_stride * (draw_count - 1) + pc.draw_buffer_offset + pc.draw_cmd_byte_size; + if (draw_buffer_max_read_offset > pc.draw_buffer_size) { + GpuavLogError2(kErrorGroupGpuPreDraw, kErrorSubCodePreDraw_DrawBufferSize, draw_count, 0); + } else if (draw_count > pc.device_limit_max_draw_indirect_count) { + GpuavLogError2(kErrorGroupGpuPreDraw, kErrorSubCodePreDraw_DrawCountLimit, draw_count, 0); + } +} diff --git a/layers/gpu/shaders/cmd_validation/dispatch.comp b/layers/gpu/shaders/cmd_validation/dispatch.comp index a6148d4f3ee..ed0cbcbb1dd 100644 --- a/layers/gpu/shaders/cmd_validation/dispatch.comp +++ b/layers/gpu/shaders/cmd_validation/dispatch.comp @@ -38,11 +38,11 @@ void main() { uint indirect_z = indirect_buffer[indirect_x_offset + 2]; if (indirect_x > limit_x) { - GpuavLogError(kErrorGroupGpuPreDispatch, kErrorSubCodePreDispatchCountLimitX, indirect_x, 0); + GpuavLogError2(kErrorGroupGpuPreDispatch, kErrorSubCodePreDispatchCountLimitX, indirect_x, 0); } else if (indirect_y > limit_y) { - GpuavLogError(kErrorGroupGpuPreDispatch, kErrorSubCodePreDispatchCountLimitY, indirect_y, 0); + GpuavLogError2(kErrorGroupGpuPreDispatch, kErrorSubCodePreDispatchCountLimitY, indirect_y, 0); } else if (indirect_z > limit_z) { - GpuavLogError(kErrorGroupGpuPreDispatch, kErrorSubCodePreDispatchCountLimitZ, indirect_z, 0); + GpuavLogError2(kErrorGroupGpuPreDispatch, kErrorSubCodePreDispatchCountLimitZ, indirect_z, 0); } } diff --git a/layers/gpu/shaders/cmd_validation/draw.vert b/layers/gpu/shaders/cmd_validation/draw.vert deleted file mode 100644 index 4d83e848a10..00000000000 --- a/layers/gpu/shaders/cmd_validation/draw.vert +++ /dev/null @@ -1,123 +0,0 @@ -// Copyright (c) 2021-2024 The Khronos Group Inc. -// Copyright (c) 2021-2024 Valve Corporation -// Copyright (c) 2021-2024 LunarG, Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#version 450 -#extension GL_GOOGLE_include_directive : enable - -layout(push_constant) uniform UniformInfo { - uint push_constant_word_0; - uint push_constant_word_1; - uint push_constant_word_2; - uint push_constant_word_3; - uint push_constant_word_4; - uint push_constant_word_5; - uint push_constant_word_6; - uint push_constant_word_7; - uint push_constant_word_8; - uint push_constant_word_9; - uint push_constant_word_10; -}; - -#include "common.h" - -#define validation_select push_constant_word_0 - -// used when testing count buffer -#define count_limit push_constant_word_1 -#define max_writes push_constant_word_2 -#define count_offset push_constant_word_3 - -// used when testing draw buffer -#define draw_count push_constant_word_1 -#define first_instance_offset push_constant_word_2 -#define draw_stride push_constant_word_3 - -// used when validating mesh draw buffer -// words 0-3 could be used to validate count -#define mesh_draw_buffer_offset push_constant_word_4 -#define mesh_draw_buffer_num_draws push_constant_word_5 -#define mesh_draw_buffer_stride push_constant_word_6 -#define max_workgroup_count_x push_constant_word_7 -#define max_workgroup_count_y push_constant_word_8 -#define max_workgroup_count_z push_constant_word_9 -#define max_workgroup_total_count push_constant_word_10 - -layout(set = kDiagPerCmdDescriptorSet, binding = 0) buffer DrawBuffer { - uint draws_buffer[]; -}; - -// CountBuffer won't be bound for non-count draws -layout(set = kDiagPerCmdDescriptorSet, binding = 1) buffer CountBuffer { - uint count_buffer[]; -}; - - -void main() { - if (gl_VertexIndex == 0) { - if (validation_select == kPreDrawSelectCountBuffer || - validation_select == kPreDrawSelectMeshCountBuffer) { - // Validate count buffer - uint count_in = count_buffer[count_offset]; - if (count_in > max_writes) { - GpuavLogError(kErrorGroupGpuPreDraw, kErrorSubCodePreDrawBufferSize, count_in, 0); - } else if (count_in > count_limit) { - GpuavLogError(kErrorGroupGpuPreDraw, kErrorSubCodePreDrawCountLimit, count_in, 0); - } - } else if (validation_select == kPreDrawSelectDrawBuffer) { - // Validate firstInstances - uint fi_index = first_instance_offset; - for (uint i = 0; i < draw_count; i++) { - if (draws_buffer[fi_index] != 0) { - GpuavLogError(kErrorGroupGpuPreDraw, kErrorSubCodePreDrawFirstInstance, i, i); - break; - } - fi_index += draw_stride; - } - } - - if (validation_select == kPreDrawSelectMeshCountBuffer || - validation_select == kPreDrawSelectMeshNoCount) { - // Validate mesh draw buffer - uint draw_buffer_index = mesh_draw_buffer_offset; - uint stride = mesh_draw_buffer_stride; - uint draw_count; - if (validation_select == kPreDrawSelectMeshCountBuffer) { - draw_count = count_buffer[count_offset]; - } else { - draw_count = mesh_draw_buffer_num_draws; - } - for (uint i = 0; i < draw_count; i++){ - uint count_x_in = draws_buffer[draw_buffer_index]; - uint count_y_in = draws_buffer[draw_buffer_index + 1]; - uint count_z_in = draws_buffer[draw_buffer_index + 2]; - if (count_x_in > max_workgroup_count_x) { - GpuavLogError(kErrorGroupGpuPreDraw, kErrorSubCodePreDrawGroupCountX, count_x_in, i); - } - if (count_y_in > max_workgroup_count_y) { - GpuavLogError(kErrorGroupGpuPreDraw, kErrorSubCodePreDrawGroupCountY, count_y_in, i); - } - if (count_z_in > max_workgroup_count_z) { - GpuavLogError(kErrorGroupGpuPreDraw, kErrorSubCodePreDrawGroupCountZ, count_z_in, i); - } - uint total = count_x_in * count_y_in * count_z_in; - if (total > max_workgroup_total_count) { - GpuavLogError(kErrorGroupGpuPreDraw, kErrorSubCodePreDrawGroupCountTotal, total, i); - } - draw_buffer_index += stride; - } - } - } -} diff --git a/layers/gpu/shaders/cmd_validation/draw_indexed.vert b/layers/gpu/shaders/cmd_validation/draw_indexed.vert new file mode 100644 index 00000000000..13d26b51acd --- /dev/null +++ b/layers/gpu/shaders/cmd_validation/draw_indexed.vert @@ -0,0 +1,68 @@ +// Copyright (c) 2021-2024 The Khronos Group Inc. +// Copyright (c) 2021-2024 Valve Corporation +// Copyright (c) 2021-2024 LunarG, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#version 450 + +#extension GL_GOOGLE_include_directive : enable + +#include "common.h" +#include "draw_push_data.h" + +layout(push_constant) uniform UniformInfo { + IndexedDrawPushData pc; +}; + +layout(set = kDiagPerCmdDescriptorSet, binding = kPreDrawBinding_IndexBuffer) +readonly buffer IndexBuffer32 { + uint index_buffer[]; +}; + +uint get_vertex_index(uint i) { + if (pc.index_width == 32) { + return index_buffer[i]; + } else if (pc.index_width == 16) { + uint load_i = i / 2; + uint packed_16_16 = index_buffer[load_i]; + // if (i % 2) == 0, take first 16 bits, else last 16 bits + uint shift = (i % 2) * 16; + return (packed_16_16 >> shift) & 0xFFFF; + } else if (pc.index_width == 8) { + uint load_i = i / 4; + uint packed_8_8_8_8 = index_buffer[load_i]; + // if (i % 4) == 0, take first 8 bits, if == 1 take second set of 8 bits, etc... + uint shift = (i % 4) * 8; + return (packed_8_8_8_8 >> shift) & 0xFF; + } + return 0; +} + +void ValidateVertexIndex(uint index_buffer_offset, uint vertex_offset, uint smallest_vertex_attributes_count) { + const uint vertex_index = get_vertex_index(index_buffer_offset) + vertex_offset; + + if (vertex_index >= smallest_vertex_attributes_count) { + GpuavLogError4(kErrorGroupGpuPreDraw, kErrorSubCode_OobVertexBuffer, index_buffer_offset, vertex_offset, vertex_index, 0); + } +} + +// Supposed to be called on a plain vkCmdDraw (not indexed, not indirect) +// Goal is to do indexed call job manually, so that we can both retrieve the value of the faulty vertex index, +// and its offset in the index buffer +void main() { + gl_PointSize = 1.0; + + const uint index_buffer_offset = gl_VertexIndex; + ValidateVertexIndex(index_buffer_offset, pc.vertex_offset, pc.smallest_vertex_attributes_count); +} diff --git a/layers/gpu/shaders/cmd_validation/draw_indexed_indirect_index_buffer.vert b/layers/gpu/shaders/cmd_validation/draw_indexed_indirect_index_buffer.vert new file mode 100644 index 00000000000..037daca4bbb --- /dev/null +++ b/layers/gpu/shaders/cmd_validation/draw_indexed_indirect_index_buffer.vert @@ -0,0 +1,82 @@ +// Copyright (c) 2021-2024 The Khronos Group Inc. +// Copyright (c) 2021-2024 Valve Corporation +// Copyright (c) 2021-2024 LunarG, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#version 450 + +#extension GL_GOOGLE_include_directive : enable + +#include "common.h" +#include "draw_push_data.h" + +layout(push_constant) uniform UniformInfo { + DrawIndexedIndirectIndexBufferPushData pc; +}; + +/* +struct VkDrawIndexedIndirectCommand { +uint indexCount; +uint instanceCount; +uint firstIndex; +uint vertexOffset; +uint firstInstance; +}; +*/ + +const uint kIndexCount = 0; +const uint kInstancekCount = 1; +const uint kFirstIndex = 2; +const uint kVertexOffset = 3; +const uint kFirstInstance = 4; + +layout(set = kDiagPerCmdDescriptorSet, binding = kPreDrawBinding_IndirectBuffer) +readonly buffer DrawBuffer { + uint draw_indexed_indirect_cmds[]; +}; + +// CountBuffer won't be bound for non-count draws +layout(set = kDiagPerCmdDescriptorSet, binding = kPreDrawBinding_CountBuffer) +readonly buffer CountBuffer { + uint count_from_buffer; +}; + +layout(set = kDiagPerCmdDescriptorSet, binding = kPreDrawBinding_IndexBuffer) +readonly buffer IndexBuffer32 { + uint index_buffer[]; +}; + +// Supposed to be called on a plain vkCmdDraw (not indexed, not indirect) +// vertexCount is the number of indices found in the bound index buffer. +// Goal is to do indexed call job manually, so that we can both retrieve the value of the faulty vertex index, +// and its offset in the index buffer +void main() { + gl_PointSize = 1.0; + + uint draw_count = 0; + if ((pc.flags & kIndexedIndirectDrawFlags_DrawCountFromBuffer) == 0) { + draw_count = pc.cpu_draw_count; + } else { + draw_count = count_from_buffer; + } + + for (uint draw_i = 0; draw_i < draw_count; ++draw_i) { + const uint draw_i_index_count = draw_indexed_indirect_cmds[draw_i * pc.draw_cmds_stride_dwords + kIndexCount]; + const uint draw_i_first_index = draw_indexed_indirect_cmds[draw_i * pc.draw_cmds_stride_dwords + kFirstIndex]; + + if (draw_i_first_index + draw_i_index_count > pc.bound_index_buffer_indices_count) { + GpuavLogError4(kErrorGroupGpuPreDraw, kErrorSubCode_OobIndexBuffer, draw_i, draw_i_first_index, draw_i_index_count, 0); + } + } +} diff --git a/layers/gpu/shaders/cmd_validation/draw_indexed_indirect_vertex_buffer.vert b/layers/gpu/shaders/cmd_validation/draw_indexed_indirect_vertex_buffer.vert new file mode 100644 index 00000000000..d7049cc00be --- /dev/null +++ b/layers/gpu/shaders/cmd_validation/draw_indexed_indirect_vertex_buffer.vert @@ -0,0 +1,117 @@ +// Copyright (c) 2021-2024 The Khronos Group Inc. +// Copyright (c) 2021-2024 Valve Corporation +// Copyright (c) 2021-2024 LunarG, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#version 450 + +#extension GL_GOOGLE_include_directive : enable + +#include "common.h" +#include "draw_push_data.h" + +layout(push_constant) uniform UniformInfo { + DrawIndexedIndirectVertexBufferPushData pc; +}; + +/* +struct VkDrawIndexedIndirectCommand { +uint indexCount; +uint instanceCount; +uint firstIndex; +uint vertexOffset; +uint firstInstance; +}; +*/ + +const uint kIndexCount = 0; +const uint kInstancekCount = 1; +const uint kFirstIndex = 2; +const uint kVertexOffset = 3; +const uint kFirstInstance = 4; + +layout(set = kDiagPerCmdDescriptorSet, binding = kPreDrawBinding_IndirectBuffer) +readonly buffer DrawBuffer { + uint draw_indexed_indirect_cmds[]; +}; + +// CountBuffer won't be bound for non-count draws +layout(set = kDiagPerCmdDescriptorSet, binding = kPreDrawBinding_CountBuffer) +readonly buffer CountBuffer { + uint count_from_buffer; +}; + +layout(set = kDiagPerCmdDescriptorSet, binding = kPreDrawBinding_IndexBuffer) +readonly buffer IndexBuffer32 { + uint index_buffer[]; +}; + +uint get_vertex_index(uint i) { + if (pc.index_width == 32) { + return index_buffer[i]; + } else if (pc.index_width == 16) { + uint load_i = i / 2; + uint packed_16_16 = index_buffer[load_i]; + // if (i % 2) == 0, take first 16 bits, else last 16 bits + uint shift = (i % 2) * 16; + return (packed_16_16 >> shift) & 0xFFFF; + } else if (pc.index_width == 8) { + uint load_i = i / 4; + uint packed_8_8_8_8 = index_buffer[load_i]; + // if (i % 4) == 0, take first 8 bits, if == 1 take second set of 8 bits, etc... + uint shift = (i % 4) * 8; + return (packed_8_8_8_8 >> shift) & 0xFF; + } + return 0; +} + +// Validate that a vertex index is within the bounds of the smallest vertex buffer +void ValidateVertexIndex(uint draw_i, uint index_buffer_offset, int vertex_offset, uint smallest_vertex_attributes_count) { + const uint vertex_index = get_vertex_index(index_buffer_offset) + vertex_offset; + + if (vertex_index >= smallest_vertex_attributes_count) { + GpuavLogError4(kErrorGroupGpuPreDraw, kErrorSubCode_OobVertexBuffer, draw_i, index_buffer_offset, vertex_offset, vertex_index); + } +} + +// Supposed to be called on a plain vkCmdDraw (not indexed, not indirect) +// vertexCount is the number of indices found in the bound index buffer. +// Goal is to do indexed call job manually, so that we can both retrieve the value of the faulty vertex index, +// and its offset in the index buffer +void main() { + gl_PointSize = 1.0; + + uint draw_count = 0; + if ((pc.flags & kIndexedIndirectDrawFlags_DrawCountFromBuffer) == 0) { + draw_count = pc.cpu_draw_count; + } else { + draw_count = count_from_buffer; + } + + const uint index_buffer_offset = gl_VertexIndex; + + for (uint draw_i = 0; draw_i < draw_count; ++draw_i) { + const uint draw_i_index_count = draw_indexed_indirect_cmds[draw_i * pc.draw_cmds_stride_dwords + kIndexCount]; + const uint draw_i_first_index = draw_indexed_indirect_cmds[draw_i * pc.draw_cmds_stride_dwords + kFirstIndex]; + + // Is index within index buffer bounds? + if (index_buffer_offset < pc.bound_index_buffer_indices_count) { + // Is index within the range of indices to check? + if (index_buffer_offset >= draw_i_first_index && index_buffer_offset < (draw_i_first_index + draw_i_index_count)) { + const int vertex_offset = int(draw_indexed_indirect_cmds[draw_i * pc.draw_cmds_stride_dwords + kVertexOffset]); + ValidateVertexIndex(draw_i, index_buffer_offset, vertex_offset, pc.smallest_vertex_attributes_count); + } + } + } +} diff --git a/layers/gpu/shaders/cmd_validation/draw_mesh_indirect.vert b/layers/gpu/shaders/cmd_validation/draw_mesh_indirect.vert new file mode 100644 index 00000000000..6718df28cc9 --- /dev/null +++ b/layers/gpu/shaders/cmd_validation/draw_mesh_indirect.vert @@ -0,0 +1,74 @@ +// Copyright (c) 2021-2024 The Khronos Group Inc. +// Copyright (c) 2021-2024 Valve Corporation +// Copyright (c) 2021-2024 LunarG, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#version 450 +#extension GL_GOOGLE_include_directive : enable + +#include "common.h" +#include "draw_push_data.h" + +layout (push_constant) +uniform UniformInfo { + DrawMeshPushData pc; +}; + +/* +struct VkDrawMeshTasksIndirectCommandEXT { + uint32_t groupCountX; + uint32_t groupCountY; + uint32_t groupCountZ; +}; +*/ + +const uint kGroupCountX = 0; +const uint kGroupCountY = 1; +const uint kGroupCountZ = 2; + +layout(set = kDiagPerCmdDescriptorSet, binding = kPreDrawBinding_IndirectBuffer) +readonly buffer DrawBuffer { + uint draw_buffer[]; +}; + +layout(set = kDiagPerCmdDescriptorSet, binding = kPreDrawBinding_CountBuffer) +readonly buffer CountBuffer { + uint count_buffer; +}; + +void main() { + gl_PointSize = 1.0; + + if ((pc.flags & kDrawMeshFlags_DrawCountFromBuffer) != 0) { + if (gl_VertexIndex >= count_buffer) return; + } + + uint x = draw_buffer[gl_VertexIndex * pc.draw_cmds_stride_dwords + kGroupCountX]; + uint y = draw_buffer[gl_VertexIndex * pc.draw_cmds_stride_dwords + kGroupCountY]; + uint z = draw_buffer[gl_VertexIndex * pc.draw_cmds_stride_dwords + kGroupCountZ]; + if (x > pc.max_workgroup_count_x) { + GpuavLogError2(kErrorGroupGpuPreDraw, kErrorSubCodePreDrawGroupCountX, x, gl_VertexIndex); + } + if (y > pc.max_workgroup_count_y) { + GpuavLogError2(kErrorGroupGpuPreDraw, kErrorSubCodePreDrawGroupCountY, y, gl_VertexIndex); + } + if (z > pc.max_workgroup_count_z) { + GpuavLogError2(kErrorGroupGpuPreDraw, kErrorSubCodePreDrawGroupCountZ, z, gl_VertexIndex); + } + + uint total = x * y * z; + if (total > pc.max_workgroup_total_count) { + GpuavLogError2(kErrorGroupGpuPreDraw, kErrorSubCodePreDrawGroupCountTotal, total, gl_VertexIndex); + } +} diff --git a/layers/gpu/shaders/cmd_validation/draw_push_data.h b/layers/gpu/shaders/cmd_validation/draw_push_data.h new file mode 100644 index 00000000000..db3723dab9d --- /dev/null +++ b/layers/gpu/shaders/cmd_validation/draw_push_data.h @@ -0,0 +1,91 @@ +// Copyright (c) 2021-2024 The Khronos Group Inc. +// Copyright (c) 2021-2024 Valve Corporation +// Copyright (c) 2021-2024 LunarG, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// Values used between the GLSL shaders and the GPU-AV logic + +// NOTE: This header is included by the instrumentation shaders and glslang doesn't support #pragma once +#ifndef GPU_SHADERS_DRAW_PUSH_DATA_H +#define GPU_SHADERS_DRAW_PUSH_DATA_H + +#ifdef __cplusplus +namespace gpuav { +namespace glsl { +using uint = unsigned int; +#else +#if defined(GL_ARB_gpu_shader_int64) +#extension GL_ARB_gpu_shader_int64 : require +#else +#error No extension available for 64-bit integers. +#endif +#endif + +// Bindings for all pre draw types +const uint kPreDrawBinding_IndirectBuffer = 0; +const uint kPreDrawBinding_CountBuffer = 1; +const uint kPreDrawBinding_IndexBuffer = 2; + +struct IndexedDrawPushData { + uint smallest_vertex_attributes_count; + uint index_width; + uint vertex_offset; +}; + +const uint kIndexedIndirectDrawFlags_DrawCountFromBuffer = uint(1) << 0; +struct DrawIndexedIndirectIndexBufferPushData { + uint flags; + uint draw_cmds_stride_dwords; + uint bound_index_buffer_indices_count; // Number of indices in the index buffer, taking index type in account. NOT a byte size. + uint cpu_draw_count; +}; + +struct DrawIndexedIndirectVertexBufferPushData { + uint flags; + uint index_width; + uint draw_cmds_stride_dwords; + uint bound_index_buffer_indices_count; // Number of indices in the index buffer, taking index type in account. NOT a byte size. + uint cpu_draw_count; + uint smallest_vertex_attributes_count; +}; + +const uint kDrawMeshFlags_DrawCountFromBuffer = uint(1) << 0; +struct DrawMeshPushData { + uint flags; + uint draw_cmds_stride_dwords; + uint max_workgroup_count_x; + uint max_workgroup_count_y; + uint max_workgroup_count_z; + uint max_workgroup_total_count; +}; + +const uint kFirstInstanceFlags_DrawCountFromBuffer = uint(1) << 0; +struct FirstInstancePushData { + uint flags; + uint draw_cmds_stride_dwords; + uint first_instance_member_pos; +}; + +struct CountBufferPushData { + uint draw_cmds_byte_stride; + uint64_t draw_buffer_offset; + uint64_t draw_buffer_size; + uint draw_cmd_byte_size; + uint device_limit_max_draw_indirect_count; +}; + +#ifdef __cplusplus +} // namespace glsl +} // namespace gpuav +#endif +#endif diff --git a/layers/gpu/shaders/cmd_validation/first_instance.vert b/layers/gpu/shaders/cmd_validation/first_instance.vert new file mode 100644 index 00000000000..794b187538c --- /dev/null +++ b/layers/gpu/shaders/cmd_validation/first_instance.vert @@ -0,0 +1,51 @@ +// Copyright (c) 2021-2024 The Khronos Group Inc. +// Copyright (c) 2021-2024 Valve Corporation +// Copyright (c) 2021-2024 LunarG, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#version 450 +#extension GL_GOOGLE_include_directive : enable + +#include "common.h" +#include "draw_push_data.h" + +layout(push_constant) +uniform PushConstants { + FirstInstancePushData pc; +}; + + +layout(set = kDiagPerCmdDescriptorSet, binding = kPreDrawBinding_IndirectBuffer) +readonly buffer DrawBuffer { + uint draw_indexed_indirect_cmds[]; +}; + +layout(set = kDiagPerCmdDescriptorSet, binding = kPreDrawBinding_CountBuffer) +readonly buffer CountBuffer { + uint count_buffer; +}; + +// Validate firstInstance member from indirect draw commands +void main() { + gl_PointSize = 1.0; + + if ((pc.flags & kFirstInstanceFlags_DrawCountFromBuffer) != 0) { + if (gl_VertexIndex >= count_buffer) return; + } + + const uint first_instance = draw_indexed_indirect_cmds[gl_VertexIndex * pc.draw_cmds_stride_dwords + pc.first_instance_member_pos]; + if (first_instance != 0) { + GpuavLogError2(kErrorGroupGpuPreDraw, kErrorSubCodePreDrawFirstInstance, gl_VertexIndex, first_instance); + } +} diff --git a/layers/gpu/shaders/cmd_validation/trace_rays.rgen b/layers/gpu/shaders/cmd_validation/trace_rays.rgen index 8f6c564c4d2..1d2e5afab88 100644 --- a/layers/gpu/shaders/cmd_validation/trace_rays.rgen +++ b/layers/gpu/shaders/cmd_validation/trace_rays.rgen @@ -47,12 +47,12 @@ layout(push_constant) uniform PushConstants { void main() { if (indirect_data.ray_query_dimensions.width > ray_query_width_limit) { - GpuavLogError(kErrorGroupGpuPreTraceRays, kErrorSubCodePreTraceRaysLimitWidth, indirect_data.ray_query_dimensions.width, 0); + GpuavLogError2(kErrorGroupGpuPreTraceRays, kErrorSubCodePreTraceRaysLimitWidth, indirect_data.ray_query_dimensions.width, 0); } if (indirect_data.ray_query_dimensions.height > ray_query_height_limit) { - GpuavLogError(kErrorGroupGpuPreTraceRays, kErrorSubCodePreTraceRaysLimitHeight, indirect_data.ray_query_dimensions.height, 0); + GpuavLogError2(kErrorGroupGpuPreTraceRays, kErrorSubCodePreTraceRaysLimitHeight, indirect_data.ray_query_dimensions.height, 0); } if (indirect_data.ray_query_dimensions.depth > ray_query_depth_limit) { - GpuavLogError(kErrorGroupGpuPreTraceRays, kErrorSubCodePreTraceRaysLimitDepth, indirect_data.ray_query_dimensions.depth, 0); + GpuavLogError2(kErrorGroupGpuPreTraceRays, kErrorSubCodePreTraceRaysLimitDepth, indirect_data.ray_query_dimensions.depth, 0); } } diff --git a/layers/gpu/shaders/gpu_error_codes.h b/layers/gpu/shaders/gpu_error_codes.h index 17fc7615559..fce52ac65af 100644 --- a/layers/gpu/shaders/gpu_error_codes.h +++ b/layers/gpu/shaders/gpu_error_codes.h @@ -77,18 +77,21 @@ const int kErrorSubCodeRayQueryDirectionFinite = 12; // Pre Draw // -const int kErrorSubCodePreDrawBufferSize = 1; -const int kErrorSubCodePreDrawCountLimit = 2; +// The draw count exceeded the draw buffer size +const int kErrorSubCodePreDraw_DrawBufferSize = 1; +// The draw count exceeded the maxDrawCount parameter to the command +const int kErrorSubCodePreDraw_DrawCountLimit = 2; +// A firstInstance field was non-zero const int kErrorSubCodePreDrawFirstInstance = 3; +// Mesh limit checks const int kErrorSubCodePreDrawGroupCountX = 4; const int kErrorSubCodePreDrawGroupCountY = 5; const int kErrorSubCodePreDrawGroupCountZ = 6; const int kErrorSubCodePreDrawGroupCountTotal = 7; - -const int kPreDrawSelectCountBuffer = 1; -const int kPreDrawSelectDrawBuffer = 2; -const int kPreDrawSelectMeshCountBuffer = 3; -const int kPreDrawSelectMeshNoCount = 4; +// The index count exceeded the index buffer size +const int kErrorSubCode_OobIndexBuffer = 8; +// An index in the index buffer exceeded the vertex buffer size +const int kErrorSubCode_OobVertexBuffer = 9; // Pre Dispatch // diff --git a/layers/gpu/shaders/gpu_error_header.h b/layers/gpu/shaders/gpu_error_header.h index 1c1257038b0..9f8db903a05 100644 --- a/layers/gpu/shaders/gpu_error_header.h +++ b/layers/gpu/shaders/gpu_error_header.h @@ -137,6 +137,8 @@ const int kInstRayQueryParamOffset_0 = kHeaderSize; // --- const int kPreActionParamOffset_0 = kHeaderSize; const int kPreActionParamOffset_1 = kHeaderSize + 1; +const int kPreActionParamOffset_2 = kHeaderSize + 2; +const int kPreActionParamOffset_3 = kHeaderSize + 3; // Sizes/Counts // ------------------- diff --git a/layers/layer_options.cpp b/layers/layer_options.cpp index 6f52b7fce9b..bdb8ecc5424 100644 --- a/layers/layer_options.cpp +++ b/layers/layer_options.cpp @@ -186,6 +186,7 @@ const char *VK_LAYER_GPUAV_INDIRECT_DRAWS_BUFFERS = "gpuav_indirect_draws_buffer const char *VK_LAYER_GPUAV_INDIRECT_DISPATCHES_BUFFERS = "gpuav_indirect_dispatches_buffers"; const char *VK_LAYER_GPUAV_INDIRECT_TRACE_RAYS_BUFFERS = "gpuav_indirect_trace_rays_buffers"; const char *VK_LAYER_GPUAV_BUFFER_COPIES = "gpuav_buffer_copies"; +const char *VK_LAYER_GPUAV_INDEX_BUFFERS = "gpuav_index_buffers"; const char *VK_LAYER_GPUAV_RESERVE_BINDING_SLOT = "gpuav_reserve_binding_slot"; const char *VK_LAYER_GPUAV_VMA_LINEAR_OUTPUT = "gpuav_vma_linear_output"; @@ -695,6 +696,9 @@ void ProcessConfigAndEnvSettings(ConfigAndEnvSettings *settings_data) { printf("Validation Setting Warning - %s was set, this is deprecated, please use %s\n", DEPRECATED_VK_LAYER_GPUAV_VALIDATE_COPIES, VK_LAYER_GPUAV_BUFFER_COPIES); } + if (vkuHasLayerSetting(layer_setting_set, VK_LAYER_GPUAV_INDEX_BUFFERS)) { + vkuGetLayerSettingValue(layer_setting_set, VK_LAYER_GPUAV_INDEX_BUFFERS, gpuav_settings.validate_index_buffers); + } } if (vkuHasLayerSetting(layer_setting_set, VK_LAYER_GPUAV_RESERVE_BINDING_SLOT)) { diff --git a/layers/state_tracker/cmd_buffer_state.cpp b/layers/state_tracker/cmd_buffer_state.cpp index 16655af2a4f..9489474f421 100644 --- a/layers/state_tracker/cmd_buffer_state.cpp +++ b/layers/state_tracker/cmd_buffer_state.cpp @@ -301,6 +301,10 @@ void CommandBuffer::ResetCBState() { label_stack_depth_ = 0; label_commands_.clear(); + push_constant_data_chunks.clear(); + push_constant_latest_used_layout.fill(VK_NULL_HANDLE); + push_constant_ranges_layout.reset(); + nesting_level = 0; transform_feedback_active = false; @@ -341,8 +345,9 @@ void CommandBuffer::ResetPushConstantRangesLayoutIfIncompatible(const vvl::Pipel return; } - push_constant_ranges_layout = pipeline_layout_state.push_constant_ranges_layout; push_constant_data_chunks.clear(); + push_constant_latest_used_layout.fill(VK_NULL_HANDLE); + push_constant_ranges_layout = pipeline_layout_state.push_constant_ranges_layout; } void CommandBuffer::Destroy() { @@ -1723,6 +1728,7 @@ void CommandBuffer::UnbindResources() { // Push constants push_constant_data_chunks.clear(); + push_constant_latest_used_layout.fill(VK_NULL_HANDLE); push_constant_ranges_layout.reset(); // Reset status of cb to force rebinding of all resources diff --git a/layers/state_tracker/cmd_buffer_state.h b/layers/state_tracker/cmd_buffer_state.h index 30530ece7b1..5f2c2164b24 100644 --- a/layers/state_tracker/cmd_buffer_state.h +++ b/layers/state_tracker/cmd_buffer_state.h @@ -216,6 +216,10 @@ class CommandBuffer : public RefcountedStateObject { bool depth_test_enable; // VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE bool depth_bounds_test_enable; + // VK_DYNAMIC_STATE_DEPTH_COMPARE_OP + VkCompareOp depth_compare_op; + // VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT + bool depth_clamp_enable; // VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE bool stencil_test_enable; // VK_DYNAMIC_STATE_STENCIL_OP @@ -227,6 +231,8 @@ class CommandBuffer : public RefcountedStateObject { VkStencilOp depth_fail_op_back; // VK_DYNAMIC_STATE_CULL_MODE VkCullModeFlags cull_mode; + // VK_DYNAMIC_STATE_FRONT_FACE + VkFrontFace front_face; // VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY VkPrimitiveTopology primitive_topology; // VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT @@ -271,6 +277,11 @@ class CommandBuffer : public RefcountedStateObject { // VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE bool primitive_restart_enable; + // VK_DYNAMIC_STATE_DEPTH_BIAS + float depth_bias_constant_factor; + float depth_bias_clamp; + float depth_bias_slope_factor; + uint32_t color_write_enable_attachment_count; // maxColorAttachments is at max 8 on all known implementations currently @@ -283,6 +294,9 @@ class CommandBuffer : public RefcountedStateObject { std::vector color_blend_equations; // VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT std::vector color_write_masks; // VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT + // VK_DYNAMIC_STATE_BLEND_CONSTANTS + std::array blend_constants; + // VK_DYNAMIC_STATE_VERTEX_INPUT_EXT, key is binding number vvl::unordered_map vertex_bindings; @@ -294,6 +308,7 @@ class CommandBuffer : public RefcountedStateObject { VkImageAspectFlags attachment_feedback_loop_enable; // VK_DYNAMIC_STATE_VIEWPORT + uint32_t first_viewport; std::vector viewports; // and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT uint32_t viewport_count; diff --git a/layers/state_tracker/state_tracker.cpp b/layers/state_tracker/state_tracker.cpp index 613daaa0ce0..70c386ed39e 100644 --- a/layers/state_tracker/state_tracker.cpp +++ b/layers/state_tracker/state_tracker.cpp @@ -2371,7 +2371,7 @@ void ValidationStateTracker::PostCallRecordCmdSetViewport(VkCommandBuffer comman uint32_t bits = ((1u << viewportCount) - 1u) << firstViewport; cb_state->viewportMask |= bits; cb_state->trashedViewportMask &= ~bits; - + cb_state->dynamic_state_value.first_viewport = firstViewport; if (cb_state->dynamic_state_value.viewports.size() < firstViewport + viewportCount) { cb_state->dynamic_state_value.viewports.resize(firstViewport + viewportCount); } @@ -2688,13 +2688,16 @@ void ValidationStateTracker::PostCallRecordCmdSetDepthBias(VkCommandBuffer comma const RecordObject &record_obj) { auto cb_state = GetWrite(commandBuffer); cb_state->RecordStateCmd(record_obj.location.function, CB_DYNAMIC_STATE_DEPTH_BIAS); + cb_state->dynamic_state_value.depth_bias_constant_factor = depthBiasConstantFactor; + cb_state->dynamic_state_value.depth_bias_clamp = depthBiasClamp; + cb_state->dynamic_state_value.depth_bias_slope_factor = depthBiasSlopeFactor; } void ValidationStateTracker::PostCallRecordCmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT *pDepthBiasInfo, const RecordObject &record_obj) { - auto cb_state = GetWrite(commandBuffer); - cb_state->RecordStateCmd(record_obj.location.function, CB_DYNAMIC_STATE_DEPTH_BIAS); + PostCallRecordCmdSetDepthBias(commandBuffer, pDepthBiasInfo->depthBiasConstantFactor, pDepthBiasInfo->depthBiasClamp, + pDepthBiasInfo->depthBiasSlopeFactor, record_obj); } void ValidationStateTracker::PostCallRecordCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, @@ -2711,6 +2714,9 @@ void ValidationStateTracker::PostCallRecordCmdSetBlendConstants(VkCommandBuffer const RecordObject &record_obj) { auto cb_state = GetWrite(commandBuffer); cb_state->RecordStateCmd(record_obj.location.function, CB_DYNAMIC_STATE_BLEND_CONSTANTS); + for (int i = 0; i < 4; ++i) { + cb_state->dynamic_state_value.blend_constants[i] = blendConstants[i]; + } } void ValidationStateTracker::PostCallRecordCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, @@ -2877,22 +2883,20 @@ void ValidationStateTracker::PostCallRecordCmdPushConstants(VkCommandBuffer comm auto cb_state = GetWrite(commandBuffer); ASSERT_AND_RETURN(cb_state); - LvlBindPoint bind_point = BindPoint_Count; + cb_state->RecordCmd(record_obj.location.function); + auto layout_state = Get(layout); + cb_state->ResetPushConstantRangesLayoutIfIncompatible(*layout_state); + if (IsStageInPipelineBindPoint(stageFlags, VK_PIPELINE_BIND_POINT_GRAPHICS)) { - bind_point = BindPoint_Graphics; + cb_state->push_constant_latest_used_layout[BindPoint_Graphics] = layout; } else if (IsStageInPipelineBindPoint(stageFlags, VK_PIPELINE_BIND_POINT_COMPUTE)) { - bind_point = BindPoint_Compute; + cb_state->push_constant_latest_used_layout[BindPoint_Compute] = layout; } else if (IsStageInPipelineBindPoint(stageFlags, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR)) { - bind_point = BindPoint_Ray_Tracing; + cb_state->push_constant_latest_used_layout[BindPoint_Ray_Tracing] = layout; } else { // Need to handle new binding point assert(false); } - cb_state->push_constant_latest_used_layout[bind_point] = layout; - - cb_state->RecordCmd(record_obj.location.function); - auto layout_state = Get(layout); - cb_state->ResetPushConstantRangesLayoutIfIncompatible(*layout_state); vvl::CommandBuffer::PushConstantData push_constant_data; push_constant_data.layout = layout; @@ -4917,6 +4921,7 @@ void ValidationStateTracker::PostCallRecordCmdSetFrontFace(VkCommandBuffer comma const RecordObject &record_obj) { auto cb_state = GetWrite(commandBuffer); cb_state->RecordStateCmd(record_obj.location.function, CB_DYNAMIC_STATE_FRONT_FACE); + cb_state->dynamic_state_value.front_face = frontFace; } void ValidationStateTracker::PostCallRecordCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, @@ -4992,8 +4997,12 @@ void ValidationStateTracker::PostCallRecordCmdBindVertexBuffers2(VkCommandBuffer auto buffer_state = Get(pBuffers[i]); vvl::VertexBufferBinding &vertex_buffer_binding = cb_state->current_vertex_buffer_binding_info[i + firstBinding]; vertex_buffer_binding.buffer = pBuffers[i]; - vertex_buffer_binding.size = (pSizes) ? pSizes[i] : VK_WHOLE_SIZE; vertex_buffer_binding.offset = pOffsets[i]; + vertex_buffer_binding.size = pSizes ? pSizes[i] : VK_WHOLE_SIZE; + if (vertex_buffer_binding.size == VK_WHOLE_SIZE) { + vertex_buffer_binding.size = vvl::Buffer::ComputeSize(buffer_state, pOffsets[i], VK_WHOLE_SIZE); + } + if (pStrides) { vertex_buffer_binding.stride = pStrides[i]; } @@ -5038,6 +5047,7 @@ void ValidationStateTracker::PostCallRecordCmdSetDepthCompareOp(VkCommandBuffer const RecordObject &record_obj) { auto cb_state = GetWrite(commandBuffer); cb_state->RecordStateCmd(record_obj.location.function, CB_DYNAMIC_STATE_DEPTH_COMPARE_OP); + cb_state->dynamic_state_value.depth_compare_op = depthCompareOp; } void ValidationStateTracker::PostCallRecordCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, @@ -5307,6 +5317,7 @@ void ValidationStateTracker::PostCallRecordCmdSetDepthClampEnableEXT(VkCommandBu const RecordObject &record_obj) { auto cb_state = GetWrite(commandBuffer); cb_state->RecordStateCmd(record_obj.location.function, CB_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT); + cb_state->dynamic_state_value.depth_clamp_enable = depthClampEnable; } void ValidationStateTracker::PostCallRecordCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode, diff --git a/layers/utils/vk_layer_utils.h b/layers/utils/vk_layer_utils.h index e5b21c5b9a7..f99d84eed7a 100644 --- a/layers/utils/vk_layer_utils.h +++ b/layers/utils/vk_layer_utils.h @@ -276,6 +276,21 @@ static inline uint32_t GetIndexAlignment(VkIndexType indexType) { } } +inline constexpr uint32_t GetIndexBitsSize(VkIndexType indexType) { + switch (indexType) { + case VK_INDEX_TYPE_UINT16: + return 16; + case VK_INDEX_TYPE_UINT32: + return 32; + case VK_INDEX_TYPE_NONE_KHR: + return 0; + case VK_INDEX_TYPE_UINT8_KHR: + return 8; + default: + return 0; + } +} + // vkspec.html#formats-planes-image-aspect static inline bool IsValidPlaneAspect(VkFormat format, VkImageAspectFlags aspect_mask) { const uint32_t planes = vkuFormatPlaneCount(format); diff --git a/layers/vulkan/generated/cmd_validation_copy_buffer_to_image_comp.cpp b/layers/vulkan/generated/cmd_validation_copy_buffer_to_image_comp.cpp index baadf5be514..cd15743152b 100644 --- a/layers/vulkan/generated/cmd_validation_copy_buffer_to_image_comp.cpp +++ b/layers/vulkan/generated/cmd_validation_copy_buffer_to_image_comp.cpp @@ -24,226 +24,248 @@ #include "cmd_validation_copy_buffer_to_image_comp.h" // To view SPIR-V, copy contents of array and paste in https://www.khronos.org/spir/visualizer/ -[[maybe_unused]] const uint32_t cmd_validation_copy_buffer_to_image_comp_size = 2200; -[[maybe_unused]] const uint32_t cmd_validation_copy_buffer_to_image_comp[2200] = { - 0x07230203, 0x00010000, 0x0008000b, 0x00000178, 0x00000000, 0x00020011, 0x00000001, 0x00020011, 0x00001161, 0x0007000a, +[[maybe_unused]] const uint32_t cmd_validation_copy_buffer_to_image_comp_size = 2418; +[[maybe_unused]] const uint32_t cmd_validation_copy_buffer_to_image_comp[2418] = { + 0x07230203, 0x00010000, 0x0008000b, 0x00000196, 0x00000000, 0x00020011, 0x00000001, 0x00020011, 0x00001161, 0x0007000a, 0x5f565053, 0x5f52484b, 0x74696238, 0x6f74735f, 0x65676172, 0x00000000, 0x0006000b, 0x00000001, 0x4c534c47, 0x6474732e, 0x3035342e, 0x00000000, 0x0003000e, 0x00000000, 0x00000001, 0x0006000f, 0x00000005, 0x00000004, 0x6e69616d, 0x00000000, - 0x0000013c, 0x00060010, 0x00000004, 0x00000011, 0x00000040, 0x00000001, 0x00000001, 0x00030003, 0x00000002, 0x000001cc, + 0x0000015a, 0x00060010, 0x00000004, 0x00000011, 0x00000040, 0x00000001, 0x00000001, 0x00030003, 0x00000002, 0x000001cc, 0x000d0004, 0x455f4c47, 0x735f5458, 0x65646168, 0x78655f72, 0x63696c70, 0x615f7469, 0x68746972, 0x6974656d, 0x79745f63, 0x5f736570, 0x38746e69, 0x00000000, 0x000a0004, 0x475f4c47, 0x4c474f4f, 0x70635f45, 0x74735f70, 0x5f656c79, 0x656e696c, 0x7269645f, 0x69746365, 0x00006576, 0x00080004, 0x475f4c47, 0x4c474f4f, 0x6e695f45, 0x64756c63, 0x69645f65, 0x74636572, 0x00657669, 0x00040005, 0x00000004, 0x6e69616d, 0x00000000, 0x00090005, 0x00000008, 0x4378614d, 0x7245646d, 0x73726f72, - 0x6e756f43, 0x61655274, 0x64656863, 0x00000028, 0x00090005, 0x00000011, 0x61757047, 0x676f4c76, 0x6f727245, 0x31752872, - 0x3b31753b, 0x753b3175, 0x00003b31, 0x00050005, 0x0000000d, 0x6f727265, 0x72675f72, 0x0070756f, 0x00060005, 0x0000000e, - 0x6f727265, 0x75735f72, 0x6f635f62, 0x00006564, 0x00040005, 0x0000000f, 0x61726170, 0x00305f6d, 0x00040005, 0x00000010, - 0x61726170, 0x00315f6d, 0x000a0005, 0x00000017, 0x54746547, 0x6c657865, 0x65747942, 0x7366664f, 0x75287465, 0x31753b31, - 0x3b31753b, 0x00000000, 0x00030005, 0x00000014, 0x00646974, 0x00050005, 0x00000015, 0x69676572, 0x695f6e6f, 0x00000000, - 0x00040005, 0x00000016, 0x6579616c, 0x00695f72, 0x00040005, 0x0000001a, 0x65786554, 0x0000006c, 0x00060006, 0x0000001a, - 0x00000000, 0x65747962, 0x66666f5f, 0x00746573, 0x00050006, 0x0000001a, 0x00000001, 0x756c6176, 0x00000065, 0x00090005, - 0x0000001e, 0x72616553, 0x6f4f6863, 0x70654462, 0x61566874, 0x2865756c, 0x753b3175, 0x00003b31, 0x00030005, 0x0000001c, - 0x00646974, 0x00050005, 0x0000001d, 0x69676572, 0x695f6e6f, 0x00000000, 0x00070005, 0x00000022, 0x6f736552, 0x65637275, - 0x65646e49, 0x66754278, 0x00726566, 0x00070006, 0x00000022, 0x00000000, 0x6f736572, 0x65637275, 0x646e695f, 0x00007865, - 0x00030005, 0x00000024, 0x00000000, 0x00080005, 0x0000002c, 0x45646d43, 0x726f7272, 0x756f4373, 0x7542746e, 0x72656666, - 0x00000000, 0x00080006, 0x0000002c, 0x00000000, 0x5f646d63, 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, 0x00030005, - 0x0000002e, 0x00000000, 0x00050005, 0x0000003f, 0x6f727245, 0x66754272, 0x00726566, 0x00050006, 0x0000003f, 0x00000000, - 0x67616c66, 0x00000073, 0x00070006, 0x0000003f, 0x00000001, 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, 0x00070006, - 0x0000003f, 0x00000002, 0x6f727265, 0x625f7372, 0x65666675, 0x00000072, 0x00030005, 0x00000041, 0x00000000, 0x00070005, - 0x0000005a, 0x69746341, 0x6e496e6f, 0x42786564, 0x65666675, 0x00000072, 0x00070006, 0x0000005a, 0x00000000, 0x69746361, - 0x695f6e6f, 0x7865646e, 0x00000000, 0x00030005, 0x0000005c, 0x00000000, 0x00060005, 0x0000007c, 0x69676572, 0x6f5f6e6f, - 0x65736666, 0x00000074, 0x00060005, 0x00000082, 0x66667542, 0x6d497265, 0x43656761, 0x0079706f, 0x00090006, 0x00000082, - 0x00000000, 0x5f637273, 0x66667562, 0x625f7265, 0x5f657479, 0x7366666f, 0x00007465, 0x00060006, 0x00000082, 0x00000001, - 0x72617473, 0x616c5f74, 0x00726579, 0x00060006, 0x00000082, 0x00000002, 0x6579616c, 0x6f635f72, 0x00746e75, 0x00060006, - 0x00000082, 0x00000003, 0x5f776f72, 0x65747865, 0x0000746e, 0x00070006, 0x00000082, 0x00000004, 0x63696c73, 0x78655f65, - 0x746e6574, 0x00000000, 0x00070006, 0x00000082, 0x00000005, 0x6579616c, 0x78655f72, 0x746e6574, 0x00000000, 0x00050006, - 0x00000082, 0x00000006, 0x5f646170, 0x00000000, 0x00070006, 0x00000082, 0x00000007, 0x69676572, 0x6f5f6e6f, 0x65736666, - 0x00000074, 0x00070006, 0x00000082, 0x00000008, 0x69676572, 0x655f6e6f, 0x6e657478, 0x00000074, 0x00060005, 0x00000084, - 0x79706f43, 0x52637253, 0x6f696765, 0x0000736e, 0x00070006, 0x00000084, 0x00000000, 0x67616d69, 0x78655f65, 0x746e6574, - 0x00000000, 0x00060006, 0x00000084, 0x00000001, 0x636f6c62, 0x69735f6b, 0x0000657a, 0x00080006, 0x00000084, 0x00000002, - 0x79706f63, 0x6765725f, 0x736e6f69, 0x756f635f, 0x0000746e, 0x00050006, 0x00000084, 0x00000003, 0x5f646170, 0x00000000, - 0x00070006, 0x00000084, 0x00000004, 0x79706f63, 0x6765725f, 0x736e6f69, 0x00000000, 0x00030005, 0x00000086, 0x00000000, - 0x00060005, 0x00000090, 0x69676572, 0x655f6e6f, 0x6e657478, 0x00000074, 0x00030005, 0x00000097, 0x00736f70, 0x00040005, - 0x000000e3, 0x6579616c, 0x00695f72, 0x00040005, 0x000000f2, 0x61726170, 0x0000006d, 0x00040005, 0x000000f4, 0x61726170, - 0x0000006d, 0x00040005, 0x000000f6, 0x61726170, 0x0000006d, 0x00050005, 0x000000fc, 0x42637253, 0x65666675, 0x00000072, - 0x00060006, 0x000000fc, 0x00000000, 0x5f637273, 0x66667562, 0x00007265, 0x00030005, 0x000000fe, 0x00000000, 0x00080005, - 0x0000013c, 0x475f6c67, 0x61626f6c, 0x766e496c, 0x7461636f, 0x496e6f69, 0x00000044, 0x00050005, 0x00000140, 0x69676572, - 0x695f6e6f, 0x00000000, 0x00040005, 0x0000015d, 0x65786574, 0x0000006c, 0x00040005, 0x0000015e, 0x61726170, 0x0000006d, - 0x00040005, 0x00000160, 0x61726170, 0x0000006d, 0x00040005, 0x0000016f, 0x61726170, 0x0000006d, 0x00040005, 0x00000170, - 0x61726170, 0x0000006d, 0x00040005, 0x00000171, 0x61726170, 0x0000006d, 0x00040005, 0x00000174, 0x61726170, 0x0000006d, - 0x00040047, 0x00000021, 0x00000006, 0x00000004, 0x00030047, 0x00000022, 0x00000003, 0x00050048, 0x00000022, 0x00000000, - 0x00000023, 0x00000000, 0x00040047, 0x00000024, 0x00000021, 0x00000002, 0x00040047, 0x00000024, 0x00000022, 0x00000000, - 0x00040047, 0x0000002b, 0x00000006, 0x00000004, 0x00030047, 0x0000002c, 0x00000003, 0x00050048, 0x0000002c, 0x00000000, - 0x00000023, 0x00000000, 0x00040047, 0x0000002e, 0x00000021, 0x00000003, 0x00040047, 0x0000002e, 0x00000022, 0x00000000, - 0x00040047, 0x0000003e, 0x00000006, 0x00000004, 0x00030047, 0x0000003f, 0x00000003, 0x00050048, 0x0000003f, 0x00000000, - 0x00000023, 0x00000000, 0x00050048, 0x0000003f, 0x00000001, 0x00000023, 0x00000004, 0x00050048, 0x0000003f, 0x00000002, - 0x00000023, 0x00000008, 0x00040047, 0x00000041, 0x00000021, 0x00000000, 0x00040047, 0x00000041, 0x00000022, 0x00000000, - 0x00040047, 0x00000059, 0x00000006, 0x00000004, 0x00030047, 0x0000005a, 0x00000003, 0x00050048, 0x0000005a, 0x00000000, - 0x00000023, 0x00000000, 0x00040047, 0x0000005c, 0x00000021, 0x00000001, 0x00040047, 0x0000005c, 0x00000022, 0x00000000, - 0x00040047, 0x0000007f, 0x00000006, 0x00000004, 0x00040047, 0x00000080, 0x00000006, 0x00000004, 0x00050048, 0x00000082, - 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x00000082, 0x00000001, 0x00000023, 0x00000004, 0x00050048, 0x00000082, - 0x00000002, 0x00000023, 0x00000008, 0x00050048, 0x00000082, 0x00000003, 0x00000023, 0x0000000c, 0x00050048, 0x00000082, - 0x00000004, 0x00000023, 0x00000010, 0x00050048, 0x00000082, 0x00000005, 0x00000023, 0x00000014, 0x00050048, 0x00000082, - 0x00000006, 0x00000023, 0x00000018, 0x00050048, 0x00000082, 0x00000007, 0x00000023, 0x00000020, 0x00050048, 0x00000082, - 0x00000008, 0x00000023, 0x00000030, 0x00040047, 0x00000083, 0x00000006, 0x00000040, 0x00030047, 0x00000084, 0x00000003, - 0x00050048, 0x00000084, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x00000084, 0x00000001, 0x00000023, 0x00000010, - 0x00050048, 0x00000084, 0x00000002, 0x00000023, 0x00000014, 0x00050048, 0x00000084, 0x00000003, 0x00000023, 0x00000018, - 0x00050048, 0x00000084, 0x00000004, 0x00000023, 0x00000020, 0x00040047, 0x00000086, 0x00000021, 0x00000001, 0x00040047, - 0x00000086, 0x00000022, 0x00000001, 0x00040047, 0x000000fb, 0x00000006, 0x00000001, 0x00030047, 0x000000fc, 0x00000003, - 0x00050048, 0x000000fc, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x000000fe, 0x00000021, 0x00000000, 0x00040047, - 0x000000fe, 0x00000022, 0x00000001, 0x00040047, 0x0000013c, 0x0000000b, 0x0000001c, 0x00020013, 0x00000002, 0x00030021, + 0x6e756f43, 0x61655274, 0x64656863, 0x00000028, 0x000b0005, 0x00000013, 0x61757047, 0x676f4c76, 0x6f727245, 0x75283472, + 0x31753b31, 0x3b31753b, 0x753b3175, 0x31753b31, 0x0000003b, 0x00050005, 0x0000000d, 0x6f727265, 0x72675f72, 0x0070756f, + 0x00060005, 0x0000000e, 0x6f727265, 0x75735f72, 0x6f635f62, 0x00006564, 0x00040005, 0x0000000f, 0x61726170, 0x00305f6d, + 0x00040005, 0x00000010, 0x61726170, 0x00315f6d, 0x00040005, 0x00000011, 0x61726170, 0x00325f6d, 0x00040005, 0x00000012, + 0x61726170, 0x00335f6d, 0x00090005, 0x0000001a, 0x61757047, 0x676f4c76, 0x6f727245, 0x75283272, 0x31753b31, 0x3b31753b, + 0x003b3175, 0x00050005, 0x00000016, 0x6f727265, 0x72675f72, 0x0070756f, 0x00060005, 0x00000017, 0x6f727265, 0x75735f72, + 0x6f635f62, 0x00006564, 0x00040005, 0x00000018, 0x61726170, 0x00305f6d, 0x00040005, 0x00000019, 0x61726170, 0x00315f6d, + 0x000a0005, 0x00000020, 0x54746547, 0x6c657865, 0x65747942, 0x7366664f, 0x75287465, 0x31753b31, 0x3b31753b, 0x00000000, + 0x00030005, 0x0000001d, 0x00646974, 0x00050005, 0x0000001e, 0x69676572, 0x695f6e6f, 0x00000000, 0x00040005, 0x0000001f, + 0x6579616c, 0x00695f72, 0x00040005, 0x00000023, 0x65786554, 0x0000006c, 0x00060006, 0x00000023, 0x00000000, 0x65747962, + 0x66666f5f, 0x00746573, 0x00050006, 0x00000023, 0x00000001, 0x756c6176, 0x00000065, 0x00090005, 0x00000027, 0x72616553, + 0x6f4f6863, 0x70654462, 0x61566874, 0x2865756c, 0x753b3175, 0x00003b31, 0x00030005, 0x00000025, 0x00646974, 0x00050005, + 0x00000026, 0x69676572, 0x695f6e6f, 0x00000000, 0x00070005, 0x0000002b, 0x6f736552, 0x65637275, 0x65646e49, 0x66754278, + 0x00726566, 0x00070006, 0x0000002b, 0x00000000, 0x6f736572, 0x65637275, 0x646e695f, 0x00007865, 0x00030005, 0x0000002d, + 0x00000000, 0x00080005, 0x00000035, 0x45646d43, 0x726f7272, 0x756f4373, 0x7542746e, 0x72656666, 0x00000000, 0x00080006, + 0x00000035, 0x00000000, 0x5f646d63, 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, 0x00030005, 0x00000037, 0x00000000, + 0x00050005, 0x00000048, 0x6f727245, 0x66754272, 0x00726566, 0x00050006, 0x00000048, 0x00000000, 0x67616c66, 0x00000073, + 0x00070006, 0x00000048, 0x00000001, 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, 0x00070006, 0x00000048, 0x00000002, + 0x6f727265, 0x625f7372, 0x65666675, 0x00000072, 0x00030005, 0x0000004a, 0x00000000, 0x00070005, 0x00000063, 0x69746341, + 0x6e496e6f, 0x42786564, 0x65666675, 0x00000072, 0x00070006, 0x00000063, 0x00000000, 0x69746361, 0x695f6e6f, 0x7865646e, + 0x00000000, 0x00030005, 0x00000065, 0x00000000, 0x00040005, 0x0000008d, 0x61726170, 0x0000006d, 0x00040005, 0x0000008f, + 0x61726170, 0x0000006d, 0x00040005, 0x00000091, 0x61726170, 0x0000006d, 0x00040005, 0x00000093, 0x61726170, 0x0000006d, + 0x00040005, 0x00000095, 0x61726170, 0x0000006d, 0x00040005, 0x00000096, 0x61726170, 0x0000006d, 0x00060005, 0x0000009a, + 0x69676572, 0x6f5f6e6f, 0x65736666, 0x00000074, 0x00060005, 0x000000a0, 0x66667542, 0x6d497265, 0x43656761, 0x0079706f, + 0x00090006, 0x000000a0, 0x00000000, 0x5f637273, 0x66667562, 0x625f7265, 0x5f657479, 0x7366666f, 0x00007465, 0x00060006, + 0x000000a0, 0x00000001, 0x72617473, 0x616c5f74, 0x00726579, 0x00060006, 0x000000a0, 0x00000002, 0x6579616c, 0x6f635f72, + 0x00746e75, 0x00060006, 0x000000a0, 0x00000003, 0x5f776f72, 0x65747865, 0x0000746e, 0x00070006, 0x000000a0, 0x00000004, + 0x63696c73, 0x78655f65, 0x746e6574, 0x00000000, 0x00070006, 0x000000a0, 0x00000005, 0x6579616c, 0x78655f72, 0x746e6574, + 0x00000000, 0x00050006, 0x000000a0, 0x00000006, 0x5f646170, 0x00000000, 0x00070006, 0x000000a0, 0x00000007, 0x69676572, + 0x6f5f6e6f, 0x65736666, 0x00000074, 0x00070006, 0x000000a0, 0x00000008, 0x69676572, 0x655f6e6f, 0x6e657478, 0x00000074, + 0x00060005, 0x000000a2, 0x79706f43, 0x52637253, 0x6f696765, 0x0000736e, 0x00070006, 0x000000a2, 0x00000000, 0x67616d69, + 0x78655f65, 0x746e6574, 0x00000000, 0x00060006, 0x000000a2, 0x00000001, 0x636f6c62, 0x69735f6b, 0x0000657a, 0x00080006, + 0x000000a2, 0x00000002, 0x79706f63, 0x6765725f, 0x736e6f69, 0x756f635f, 0x0000746e, 0x00050006, 0x000000a2, 0x00000003, + 0x5f646170, 0x00000000, 0x00070006, 0x000000a2, 0x00000004, 0x79706f63, 0x6765725f, 0x736e6f69, 0x00000000, 0x00030005, + 0x000000a4, 0x00000000, 0x00060005, 0x000000ae, 0x69676572, 0x655f6e6f, 0x6e657478, 0x00000074, 0x00030005, 0x000000b5, + 0x00736f70, 0x00040005, 0x00000101, 0x6579616c, 0x00695f72, 0x00040005, 0x00000110, 0x61726170, 0x0000006d, 0x00040005, + 0x00000112, 0x61726170, 0x0000006d, 0x00040005, 0x00000114, 0x61726170, 0x0000006d, 0x00050005, 0x0000011a, 0x42637253, + 0x65666675, 0x00000072, 0x00060006, 0x0000011a, 0x00000000, 0x5f637273, 0x66667562, 0x00007265, 0x00030005, 0x0000011c, + 0x00000000, 0x00080005, 0x0000015a, 0x475f6c67, 0x61626f6c, 0x766e496c, 0x7461636f, 0x496e6f69, 0x00000044, 0x00050005, + 0x0000015e, 0x69676572, 0x695f6e6f, 0x00000000, 0x00040005, 0x0000017b, 0x65786574, 0x0000006c, 0x00040005, 0x0000017c, + 0x61726170, 0x0000006d, 0x00040005, 0x0000017e, 0x61726170, 0x0000006d, 0x00040005, 0x0000018d, 0x61726170, 0x0000006d, + 0x00040005, 0x0000018e, 0x61726170, 0x0000006d, 0x00040005, 0x0000018f, 0x61726170, 0x0000006d, 0x00040005, 0x00000192, + 0x61726170, 0x0000006d, 0x00040047, 0x0000002a, 0x00000006, 0x00000004, 0x00030047, 0x0000002b, 0x00000003, 0x00040048, + 0x0000002b, 0x00000000, 0x00000018, 0x00050048, 0x0000002b, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x0000002d, + 0x00000021, 0x00000002, 0x00040047, 0x0000002d, 0x00000022, 0x00000000, 0x00040047, 0x00000034, 0x00000006, 0x00000004, + 0x00030047, 0x00000035, 0x00000003, 0x00050048, 0x00000035, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000037, + 0x00000021, 0x00000003, 0x00040047, 0x00000037, 0x00000022, 0x00000000, 0x00040047, 0x00000047, 0x00000006, 0x00000004, + 0x00030047, 0x00000048, 0x00000003, 0x00050048, 0x00000048, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x00000048, + 0x00000001, 0x00000023, 0x00000004, 0x00050048, 0x00000048, 0x00000002, 0x00000023, 0x00000008, 0x00040047, 0x0000004a, + 0x00000021, 0x00000000, 0x00040047, 0x0000004a, 0x00000022, 0x00000000, 0x00040047, 0x00000062, 0x00000006, 0x00000004, + 0x00030047, 0x00000063, 0x00000003, 0x00040048, 0x00000063, 0x00000000, 0x00000018, 0x00050048, 0x00000063, 0x00000000, + 0x00000023, 0x00000000, 0x00040047, 0x00000065, 0x00000021, 0x00000001, 0x00040047, 0x00000065, 0x00000022, 0x00000000, + 0x00040047, 0x0000009d, 0x00000006, 0x00000004, 0x00040047, 0x0000009e, 0x00000006, 0x00000004, 0x00050048, 0x000000a0, + 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x000000a0, 0x00000001, 0x00000023, 0x00000004, 0x00050048, 0x000000a0, + 0x00000002, 0x00000023, 0x00000008, 0x00050048, 0x000000a0, 0x00000003, 0x00000023, 0x0000000c, 0x00050048, 0x000000a0, + 0x00000004, 0x00000023, 0x00000010, 0x00050048, 0x000000a0, 0x00000005, 0x00000023, 0x00000014, 0x00050048, 0x000000a0, + 0x00000006, 0x00000023, 0x00000018, 0x00050048, 0x000000a0, 0x00000007, 0x00000023, 0x00000020, 0x00050048, 0x000000a0, + 0x00000008, 0x00000023, 0x00000030, 0x00040047, 0x000000a1, 0x00000006, 0x00000040, 0x00030047, 0x000000a2, 0x00000003, + 0x00050048, 0x000000a2, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x000000a2, 0x00000001, 0x00000023, 0x00000010, + 0x00050048, 0x000000a2, 0x00000002, 0x00000023, 0x00000014, 0x00050048, 0x000000a2, 0x00000003, 0x00000023, 0x00000018, + 0x00050048, 0x000000a2, 0x00000004, 0x00000023, 0x00000020, 0x00040047, 0x000000a4, 0x00000021, 0x00000001, 0x00040047, + 0x000000a4, 0x00000022, 0x00000001, 0x00040047, 0x00000119, 0x00000006, 0x00000001, 0x00030047, 0x0000011a, 0x00000003, + 0x00050048, 0x0000011a, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x0000011c, 0x00000021, 0x00000000, 0x00040047, + 0x0000011c, 0x00000022, 0x00000001, 0x00040047, 0x0000015a, 0x0000000b, 0x0000001c, 0x00020013, 0x00000002, 0x00030021, 0x00000003, 0x00000002, 0x00020014, 0x00000006, 0x00030021, 0x00000007, 0x00000006, 0x00040015, 0x0000000a, 0x00000020, - 0x00000000, 0x00040020, 0x0000000b, 0x00000007, 0x0000000a, 0x00070021, 0x0000000c, 0x00000002, 0x0000000b, 0x0000000b, - 0x0000000b, 0x0000000b, 0x00060021, 0x00000013, 0x0000000a, 0x0000000b, 0x0000000b, 0x0000000b, 0x00030016, 0x00000019, - 0x00000020, 0x0004001e, 0x0000001a, 0x0000000a, 0x00000019, 0x00050021, 0x0000001b, 0x0000001a, 0x0000000b, 0x0000000b, - 0x0003001d, 0x00000021, 0x0000000a, 0x0003001e, 0x00000022, 0x00000021, 0x00040020, 0x00000023, 0x00000002, 0x00000022, - 0x0004003b, 0x00000023, 0x00000024, 0x00000002, 0x00040015, 0x00000025, 0x00000020, 0x00000001, 0x0004002b, 0x00000025, - 0x00000026, 0x00000000, 0x00040020, 0x00000027, 0x00000002, 0x0000000a, 0x0003001d, 0x0000002b, 0x0000000a, 0x0003001e, - 0x0000002c, 0x0000002b, 0x00040020, 0x0000002d, 0x00000002, 0x0000002c, 0x0004003b, 0x0000002d, 0x0000002e, 0x00000002, - 0x0004002b, 0x0000000a, 0x00000031, 0x00000001, 0x0004002b, 0x0000000a, 0x00000032, 0x00000000, 0x0004002b, 0x0000000a, - 0x00000035, 0x00000006, 0x0003001d, 0x0000003e, 0x0000000a, 0x0005001e, 0x0000003f, 0x0000000a, 0x0000000a, 0x0000003e, - 0x00040020, 0x00000040, 0x00000002, 0x0000003f, 0x0004003b, 0x00000040, 0x00000041, 0x00000002, 0x0004002b, 0x00000025, - 0x00000042, 0x00000001, 0x0004002b, 0x0000000a, 0x00000044, 0x00000010, 0x0004002b, 0x00000025, 0x00000052, 0x00000002, - 0x0004002b, 0x0000000a, 0x00000057, 0x00000007, 0x0003001d, 0x00000059, 0x0000000a, 0x0003001e, 0x0000005a, 0x00000059, - 0x00040020, 0x0000005b, 0x00000002, 0x0000005a, 0x0004003b, 0x0000005b, 0x0000005c, 0x00000002, 0x0004002b, 0x0000000a, - 0x00000061, 0x00000008, 0x0004002b, 0x0000000a, 0x00000067, 0x00000009, 0x0004002b, 0x0000000a, 0x0000006c, 0x0000000a, - 0x0004002b, 0x0000000a, 0x00000071, 0x0000000b, 0x0004002b, 0x0000000a, 0x00000076, 0x0000000c, 0x00040017, 0x0000007a, - 0x00000025, 0x00000003, 0x00040020, 0x0000007b, 0x00000007, 0x0000007a, 0x00040017, 0x0000007d, 0x0000000a, 0x00000004, - 0x0004002b, 0x0000000a, 0x0000007e, 0x00000002, 0x0004001c, 0x0000007f, 0x0000000a, 0x0000007e, 0x0004001c, 0x00000080, - 0x0000000a, 0x0000007e, 0x00040017, 0x00000081, 0x00000025, 0x00000004, 0x000b001e, 0x00000082, 0x0000000a, 0x0000000a, - 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x00000080, 0x00000081, 0x0000007d, 0x0003001d, 0x00000083, 0x00000082, - 0x0007001e, 0x00000084, 0x0000007d, 0x0000000a, 0x0000000a, 0x0000007f, 0x00000083, 0x00040020, 0x00000085, 0x00000002, - 0x00000084, 0x0004003b, 0x00000085, 0x00000086, 0x00000002, 0x0004002b, 0x00000025, 0x00000087, 0x00000004, 0x0004002b, - 0x00000025, 0x00000089, 0x00000007, 0x00040020, 0x0000008a, 0x00000002, 0x00000081, 0x00040017, 0x0000008e, 0x0000000a, - 0x00000003, 0x00040020, 0x0000008f, 0x00000007, 0x0000008e, 0x0004002b, 0x00000025, 0x00000092, 0x00000008, 0x00040020, - 0x00000093, 0x00000002, 0x0000007d, 0x00040020, 0x0000009d, 0x00000007, 0x00000025, 0x0004002b, 0x00000025, 0x000000cc, - 0x00000003, 0x0004002b, 0x00000025, 0x000000db, 0x00000005, 0x00040015, 0x000000fa, 0x00000008, 0x00000000, 0x0003001d, - 0x000000fb, 0x000000fa, 0x0003001e, 0x000000fc, 0x000000fb, 0x00040020, 0x000000fd, 0x00000002, 0x000000fc, 0x0004003b, - 0x000000fd, 0x000000fe, 0x00000002, 0x00040020, 0x00000100, 0x00000002, 0x000000fa, 0x0004002b, 0x0000000a, 0x00000112, - 0x00000003, 0x0004002b, 0x00000025, 0x0000011d, 0x00000010, 0x0004002b, 0x00000025, 0x00000121, 0x00000018, 0x00040020, - 0x00000124, 0x00000007, 0x00000019, 0x0004002b, 0x00000019, 0x00000129, 0x00000000, 0x0004002b, 0x00000019, 0x0000012c, - 0x3f800000, 0x0005002c, 0x0000001a, 0x00000137, 0x00000032, 0x00000129, 0x00040020, 0x0000013b, 0x00000001, 0x0000008e, - 0x0004003b, 0x0000013b, 0x0000013c, 0x00000001, 0x00040020, 0x0000013d, 0x00000001, 0x0000000a, 0x00040020, 0x0000015c, - 0x00000007, 0x0000001a, 0x00050036, 0x00000002, 0x00000004, 0x00000000, 0x00000003, 0x000200f8, 0x00000005, 0x0004003b, - 0x0000000b, 0x00000140, 0x00000007, 0x0004003b, 0x0000015c, 0x0000015d, 0x00000007, 0x0004003b, 0x0000000b, 0x0000015e, - 0x00000007, 0x0004003b, 0x0000000b, 0x00000160, 0x00000007, 0x0004003b, 0x0000000b, 0x0000016f, 0x00000007, 0x0004003b, - 0x0000000b, 0x00000170, 0x00000007, 0x0004003b, 0x0000000b, 0x00000171, 0x00000007, 0x0004003b, 0x0000000b, 0x00000174, - 0x00000007, 0x00050041, 0x0000013d, 0x0000013e, 0x0000013c, 0x00000032, 0x0004003d, 0x0000000a, 0x0000013f, 0x0000013e, - 0x0003003e, 0x00000140, 0x00000032, 0x000200f9, 0x00000141, 0x000200f8, 0x00000141, 0x000400f6, 0x00000143, 0x00000144, - 0x00000000, 0x000200f9, 0x00000145, 0x000200f8, 0x00000145, 0x0004003d, 0x0000000a, 0x00000146, 0x00000140, 0x00050041, - 0x00000027, 0x00000147, 0x00000086, 0x00000052, 0x0004003d, 0x0000000a, 0x00000148, 0x00000147, 0x000500b0, 0x00000006, - 0x00000149, 0x00000146, 0x00000148, 0x000400fa, 0x00000149, 0x00000142, 0x00000143, 0x000200f8, 0x00000142, 0x0004003d, - 0x0000000a, 0x0000014b, 0x00000140, 0x00080041, 0x00000027, 0x0000014c, 0x00000086, 0x00000087, 0x0000014b, 0x00000092, - 0x00000032, 0x0004003d, 0x0000000a, 0x0000014d, 0x0000014c, 0x00080041, 0x00000027, 0x0000014f, 0x00000086, 0x00000087, - 0x0000014b, 0x00000092, 0x00000031, 0x0004003d, 0x0000000a, 0x00000150, 0x0000014f, 0x00050084, 0x0000000a, 0x00000151, - 0x0000014d, 0x00000150, 0x00080041, 0x00000027, 0x00000153, 0x00000086, 0x00000087, 0x0000014b, 0x00000092, 0x0000007e, - 0x0004003d, 0x0000000a, 0x00000154, 0x00000153, 0x00050084, 0x0000000a, 0x00000155, 0x00000151, 0x00000154, 0x000500ae, - 0x00000006, 0x00000158, 0x0000013f, 0x00000155, 0x000300f7, 0x0000015a, 0x00000000, 0x000400fa, 0x00000158, 0x00000159, - 0x0000015a, 0x000200f8, 0x00000159, 0x000200f9, 0x00000144, 0x000200f8, 0x0000015a, 0x0003003e, 0x0000015e, 0x0000013f, - 0x0004003d, 0x0000000a, 0x00000161, 0x00000140, 0x0003003e, 0x00000160, 0x00000161, 0x00060039, 0x0000001a, 0x00000162, - 0x0000001e, 0x0000015e, 0x00000160, 0x0003003e, 0x0000015d, 0x00000162, 0x00050041, 0x00000124, 0x00000163, 0x0000015d, - 0x00000042, 0x0004003d, 0x00000019, 0x00000164, 0x00000163, 0x000500b8, 0x00000006, 0x00000165, 0x00000164, 0x00000129, - 0x000400a8, 0x00000006, 0x00000166, 0x00000165, 0x000300f7, 0x00000168, 0x00000000, 0x000400fa, 0x00000166, 0x00000167, - 0x00000168, 0x000200f8, 0x00000167, 0x00050041, 0x00000124, 0x00000169, 0x0000015d, 0x00000042, 0x0004003d, 0x00000019, - 0x0000016a, 0x00000169, 0x000500ba, 0x00000006, 0x0000016b, 0x0000016a, 0x0000012c, 0x000200f9, 0x00000168, 0x000200f8, - 0x00000168, 0x000700f5, 0x00000006, 0x0000016c, 0x00000165, 0x0000015a, 0x0000016b, 0x00000167, 0x000300f7, 0x0000016e, - 0x00000000, 0x000400fa, 0x0000016c, 0x0000016d, 0x0000016e, 0x000200f8, 0x0000016d, 0x0003003e, 0x0000016f, 0x00000057, - 0x0003003e, 0x00000170, 0x00000031, 0x00050041, 0x0000000b, 0x00000172, 0x0000015d, 0x00000026, 0x0004003d, 0x0000000a, - 0x00000173, 0x00000172, 0x0003003e, 0x00000171, 0x00000173, 0x0003003e, 0x00000174, 0x00000032, 0x00080039, 0x00000002, - 0x00000175, 0x00000011, 0x0000016f, 0x00000170, 0x00000171, 0x00000174, 0x000200f9, 0x0000016e, 0x000200f8, 0x0000016e, - 0x000200f9, 0x00000144, 0x000200f8, 0x00000144, 0x0004003d, 0x0000000a, 0x00000176, 0x00000140, 0x00050080, 0x0000000a, - 0x00000177, 0x00000176, 0x00000042, 0x0003003e, 0x00000140, 0x00000177, 0x000200f9, 0x00000141, 0x000200f8, 0x00000143, - 0x000100fd, 0x00010038, 0x00050036, 0x00000006, 0x00000008, 0x00000000, 0x00000007, 0x000200f8, 0x00000009, 0x00060041, - 0x00000027, 0x00000028, 0x00000024, 0x00000026, 0x00000026, 0x0004003d, 0x0000000a, 0x00000029, 0x00000028, 0x00060041, - 0x00000027, 0x00000030, 0x0000002e, 0x00000026, 0x00000029, 0x000700ea, 0x0000000a, 0x00000033, 0x00000030, 0x00000031, - 0x00000032, 0x00000031, 0x000500ae, 0x00000006, 0x00000036, 0x00000033, 0x00000035, 0x000200fe, 0x00000036, 0x00010038, - 0x00050036, 0x00000002, 0x00000011, 0x00000000, 0x0000000c, 0x00030037, 0x0000000b, 0x0000000d, 0x00030037, 0x0000000b, - 0x0000000e, 0x00030037, 0x0000000b, 0x0000000f, 0x00030037, 0x0000000b, 0x00000010, 0x000200f8, 0x00000012, 0x00040039, - 0x00000006, 0x00000039, 0x00000008, 0x000300f7, 0x0000003b, 0x00000000, 0x000400fa, 0x00000039, 0x0000003a, 0x0000003b, - 0x000200f8, 0x0000003a, 0x000100fd, 0x000200f8, 0x0000003b, 0x00050041, 0x00000027, 0x00000043, 0x00000041, 0x00000042, - 0x000700ea, 0x0000000a, 0x00000045, 0x00000043, 0x00000031, 0x00000032, 0x00000044, 0x00050080, 0x0000000a, 0x00000049, - 0x00000045, 0x00000044, 0x00050044, 0x0000000a, 0x0000004a, 0x00000041, 0x00000002, 0x0004007c, 0x00000025, 0x0000004b, - 0x0000004a, 0x0004007c, 0x0000000a, 0x0000004c, 0x0000004b, 0x000500ac, 0x00000006, 0x0000004d, 0x00000049, 0x0000004c, - 0x000300f7, 0x00000050, 0x00000000, 0x000400fa, 0x0000004d, 0x0000004f, 0x00000050, 0x000200f8, 0x0000004f, 0x000100fd, - 0x000200f8, 0x00000050, 0x00060041, 0x00000027, 0x00000055, 0x00000041, 0x00000052, 0x00000045, 0x0003003e, 0x00000055, - 0x00000044, 0x00050080, 0x0000000a, 0x00000058, 0x00000045, 0x00000057, 0x00060041, 0x00000027, 0x0000005d, 0x0000005c, - 0x00000026, 0x00000026, 0x0004003d, 0x0000000a, 0x0000005e, 0x0000005d, 0x00060041, 0x00000027, 0x0000005f, 0x00000041, - 0x00000052, 0x00000058, 0x0003003e, 0x0000005f, 0x0000005e, 0x00050080, 0x0000000a, 0x00000062, 0x00000045, 0x00000061, - 0x00060041, 0x00000027, 0x00000063, 0x00000024, 0x00000026, 0x00000026, 0x0004003d, 0x0000000a, 0x00000064, 0x00000063, - 0x00060041, 0x00000027, 0x00000065, 0x00000041, 0x00000052, 0x00000062, 0x0003003e, 0x00000065, 0x00000064, 0x00050080, - 0x0000000a, 0x00000068, 0x00000045, 0x00000067, 0x0004003d, 0x0000000a, 0x00000069, 0x0000000d, 0x00060041, 0x00000027, - 0x0000006a, 0x00000041, 0x00000052, 0x00000068, 0x0003003e, 0x0000006a, 0x00000069, 0x00050080, 0x0000000a, 0x0000006d, - 0x00000045, 0x0000006c, 0x0004003d, 0x0000000a, 0x0000006e, 0x0000000e, 0x00060041, 0x00000027, 0x0000006f, 0x00000041, - 0x00000052, 0x0000006d, 0x0003003e, 0x0000006f, 0x0000006e, 0x00050080, 0x0000000a, 0x00000072, 0x00000045, 0x00000071, - 0x0004003d, 0x0000000a, 0x00000073, 0x0000000f, 0x00060041, 0x00000027, 0x00000074, 0x00000041, 0x00000052, 0x00000072, - 0x0003003e, 0x00000074, 0x00000073, 0x00050080, 0x0000000a, 0x00000077, 0x00000045, 0x00000076, 0x0004003d, 0x0000000a, - 0x00000078, 0x00000010, 0x00060041, 0x00000027, 0x00000079, 0x00000041, 0x00000052, 0x00000077, 0x0003003e, 0x00000079, - 0x00000078, 0x000100fd, 0x00010038, 0x00050036, 0x0000000a, 0x00000017, 0x00000000, 0x00000013, 0x00030037, 0x0000000b, - 0x00000014, 0x00030037, 0x0000000b, 0x00000015, 0x00030037, 0x0000000b, 0x00000016, 0x000200f8, 0x00000018, 0x0004003b, - 0x0000007b, 0x0000007c, 0x00000007, 0x0004003b, 0x0000008f, 0x00000090, 0x00000007, 0x0004003b, 0x0000007b, 0x00000097, - 0x00000007, 0x0004003d, 0x0000000a, 0x00000088, 0x00000015, 0x00070041, 0x0000008a, 0x0000008b, 0x00000086, 0x00000087, - 0x00000088, 0x00000089, 0x0004003d, 0x00000081, 0x0000008c, 0x0000008b, 0x0008004f, 0x0000007a, 0x0000008d, 0x0000008c, - 0x0000008c, 0x00000000, 0x00000001, 0x00000002, 0x0003003e, 0x0000007c, 0x0000008d, 0x0004003d, 0x0000000a, 0x00000091, - 0x00000015, 0x00070041, 0x00000093, 0x00000094, 0x00000086, 0x00000087, 0x00000091, 0x00000092, 0x0004003d, 0x0000007d, - 0x00000095, 0x00000094, 0x0008004f, 0x0000008e, 0x00000096, 0x00000095, 0x00000095, 0x00000000, 0x00000001, 0x00000002, - 0x0003003e, 0x00000090, 0x00000096, 0x0004003d, 0x0000000a, 0x00000098, 0x00000014, 0x00050041, 0x0000000b, 0x00000099, - 0x00000090, 0x00000032, 0x0004003d, 0x0000000a, 0x0000009a, 0x00000099, 0x00050089, 0x0000000a, 0x0000009b, 0x00000098, - 0x0000009a, 0x0004007c, 0x00000025, 0x0000009c, 0x0000009b, 0x00050041, 0x0000009d, 0x0000009e, 0x0000007c, 0x00000032, - 0x0004003d, 0x00000025, 0x0000009f, 0x0000009e, 0x00050080, 0x00000025, 0x000000a0, 0x0000009c, 0x0000009f, 0x00050041, - 0x0000009d, 0x000000a1, 0x00000097, 0x00000032, 0x0003003e, 0x000000a1, 0x000000a0, 0x0004003d, 0x0000000a, 0x000000a2, - 0x00000014, 0x00050041, 0x0000000b, 0x000000a3, 0x00000090, 0x00000032, 0x0004003d, 0x0000000a, 0x000000a4, 0x000000a3, - 0x00050086, 0x0000000a, 0x000000a5, 0x000000a2, 0x000000a4, 0x00050041, 0x0000000b, 0x000000a6, 0x00000090, 0x00000032, - 0x0004003d, 0x0000000a, 0x000000a7, 0x000000a6, 0x00050041, 0x0000000b, 0x000000a8, 0x00000090, 0x00000031, 0x0004003d, - 0x0000000a, 0x000000a9, 0x000000a8, 0x00050084, 0x0000000a, 0x000000aa, 0x000000a7, 0x000000a9, 0x00050089, 0x0000000a, - 0x000000ab, 0x000000a5, 0x000000aa, 0x0004007c, 0x00000025, 0x000000ac, 0x000000ab, 0x00050041, 0x0000009d, 0x000000ad, - 0x0000007c, 0x00000031, 0x0004003d, 0x00000025, 0x000000ae, 0x000000ad, 0x00050080, 0x00000025, 0x000000af, 0x000000ac, - 0x000000ae, 0x00050041, 0x0000009d, 0x000000b0, 0x00000097, 0x00000031, 0x0003003e, 0x000000b0, 0x000000af, 0x0004003d, - 0x0000000a, 0x000000b1, 0x00000014, 0x00050041, 0x0000000b, 0x000000b2, 0x00000090, 0x00000032, 0x0004003d, 0x0000000a, - 0x000000b3, 0x000000b2, 0x00050041, 0x0000000b, 0x000000b4, 0x00000090, 0x00000031, 0x0004003d, 0x0000000a, 0x000000b5, - 0x000000b4, 0x00050084, 0x0000000a, 0x000000b6, 0x000000b3, 0x000000b5, 0x00050086, 0x0000000a, 0x000000b7, 0x000000b1, - 0x000000b6, 0x0004007c, 0x00000025, 0x000000b8, 0x000000b7, 0x00050041, 0x0000009d, 0x000000b9, 0x0000007c, 0x0000007e, - 0x0004003d, 0x00000025, 0x000000ba, 0x000000b9, 0x00050080, 0x00000025, 0x000000bb, 0x000000b8, 0x000000ba, 0x00050041, - 0x0000009d, 0x000000bc, 0x00000097, 0x0000007e, 0x0003003e, 0x000000bc, 0x000000bb, 0x0004003d, 0x0000000a, 0x000000be, - 0x00000015, 0x00070041, 0x00000027, 0x000000bf, 0x00000086, 0x00000087, 0x000000be, 0x00000026, 0x0004003d, 0x0000000a, - 0x000000c0, 0x000000bf, 0x00050041, 0x0000009d, 0x000000c1, 0x00000097, 0x00000032, 0x0004003d, 0x00000025, 0x000000c2, - 0x000000c1, 0x0004007c, 0x0000000a, 0x000000c3, 0x000000c2, 0x00050041, 0x00000027, 0x000000c4, 0x00000086, 0x00000042, - 0x0004003d, 0x0000000a, 0x000000c5, 0x000000c4, 0x00050084, 0x0000000a, 0x000000c6, 0x000000c3, 0x000000c5, 0x00050080, - 0x0000000a, 0x000000c7, 0x000000c0, 0x000000c6, 0x00050041, 0x0000009d, 0x000000c8, 0x00000097, 0x00000031, 0x0004003d, - 0x00000025, 0x000000c9, 0x000000c8, 0x0004007c, 0x0000000a, 0x000000ca, 0x000000c9, 0x0004003d, 0x0000000a, 0x000000cb, - 0x00000015, 0x00070041, 0x00000027, 0x000000cd, 0x00000086, 0x00000087, 0x000000cb, 0x000000cc, 0x0004003d, 0x0000000a, - 0x000000ce, 0x000000cd, 0x00050084, 0x0000000a, 0x000000cf, 0x000000ca, 0x000000ce, 0x00050080, 0x0000000a, 0x000000d0, - 0x000000c7, 0x000000cf, 0x00050041, 0x0000009d, 0x000000d1, 0x00000097, 0x0000007e, 0x0004003d, 0x00000025, 0x000000d2, - 0x000000d1, 0x0004007c, 0x0000000a, 0x000000d3, 0x000000d2, 0x0004003d, 0x0000000a, 0x000000d4, 0x00000015, 0x00070041, - 0x00000027, 0x000000d5, 0x00000086, 0x00000087, 0x000000d4, 0x00000087, 0x0004003d, 0x0000000a, 0x000000d6, 0x000000d5, - 0x00050084, 0x0000000a, 0x000000d7, 0x000000d3, 0x000000d6, 0x00050080, 0x0000000a, 0x000000d8, 0x000000d0, 0x000000d7, - 0x0004003d, 0x0000000a, 0x000000d9, 0x00000016, 0x0004003d, 0x0000000a, 0x000000da, 0x00000015, 0x00070041, 0x00000027, - 0x000000dc, 0x00000086, 0x00000087, 0x000000da, 0x000000db, 0x0004003d, 0x0000000a, 0x000000dd, 0x000000dc, 0x00050084, - 0x0000000a, 0x000000de, 0x000000d9, 0x000000dd, 0x00050080, 0x0000000a, 0x000000df, 0x000000d8, 0x000000de, 0x000200fe, - 0x000000df, 0x00010038, 0x00050036, 0x0000001a, 0x0000001e, 0x00000000, 0x0000001b, 0x00030037, 0x0000000b, 0x0000001c, - 0x00030037, 0x0000000b, 0x0000001d, 0x000200f8, 0x0000001f, 0x0004003b, 0x0000000b, 0x000000e3, 0x00000007, 0x0004003b, - 0x0000000b, 0x000000f2, 0x00000007, 0x0004003b, 0x0000000b, 0x000000f4, 0x00000007, 0x0004003b, 0x0000000b, 0x000000f6, - 0x00000007, 0x0004003d, 0x0000000a, 0x000000e4, 0x0000001d, 0x00070041, 0x00000027, 0x000000e5, 0x00000086, 0x00000087, - 0x000000e4, 0x00000042, 0x0004003d, 0x0000000a, 0x000000e6, 0x000000e5, 0x0003003e, 0x000000e3, 0x000000e6, 0x000200f9, - 0x000000e7, 0x000200f8, 0x000000e7, 0x000400f6, 0x000000e9, 0x000000ea, 0x00000000, 0x000200f9, 0x000000eb, 0x000200f8, - 0x000000eb, 0x0004003d, 0x0000000a, 0x000000ec, 0x000000e3, 0x0004003d, 0x0000000a, 0x000000ed, 0x0000001d, 0x00070041, - 0x00000027, 0x000000ee, 0x00000086, 0x00000087, 0x000000ed, 0x00000052, 0x0004003d, 0x0000000a, 0x000000ef, 0x000000ee, - 0x000500b0, 0x00000006, 0x000000f0, 0x000000ec, 0x000000ef, 0x000400fa, 0x000000f0, 0x000000e8, 0x000000e9, 0x000200f8, - 0x000000e8, 0x0004003d, 0x0000000a, 0x000000f3, 0x0000001c, 0x0003003e, 0x000000f2, 0x000000f3, 0x0004003d, 0x0000000a, - 0x000000f5, 0x0000001d, 0x0003003e, 0x000000f4, 0x000000f5, 0x0004003d, 0x0000000a, 0x000000f7, 0x000000e3, 0x0003003e, - 0x000000f6, 0x000000f7, 0x00070039, 0x0000000a, 0x000000f8, 0x00000017, 0x000000f2, 0x000000f4, 0x000000f6, 0x00060041, - 0x00000100, 0x00000101, 0x000000fe, 0x00000026, 0x000000f8, 0x0004003d, 0x000000fa, 0x00000102, 0x00000101, 0x00040071, - 0x0000000a, 0x00000103, 0x00000102, 0x00050080, 0x0000000a, 0x00000106, 0x000000f8, 0x00000031, 0x00060041, 0x00000100, - 0x00000107, 0x000000fe, 0x00000026, 0x00000106, 0x0004003d, 0x000000fa, 0x00000108, 0x00000107, 0x00040071, 0x0000000a, - 0x00000109, 0x00000108, 0x00050080, 0x0000000a, 0x0000010c, 0x000000f8, 0x0000007e, 0x00060041, 0x00000100, 0x0000010d, - 0x000000fe, 0x00000026, 0x0000010c, 0x0004003d, 0x000000fa, 0x0000010e, 0x0000010d, 0x00040071, 0x0000000a, 0x0000010f, - 0x0000010e, 0x00050080, 0x0000000a, 0x00000113, 0x000000f8, 0x00000112, 0x00060041, 0x00000100, 0x00000114, 0x000000fe, - 0x00000026, 0x00000113, 0x0004003d, 0x000000fa, 0x00000115, 0x00000114, 0x00040071, 0x0000000a, 0x00000116, 0x00000115, - 0x000500c4, 0x0000000a, 0x0000011a, 0x00000109, 0x00000092, 0x000500c5, 0x0000000a, 0x0000011b, 0x00000103, 0x0000011a, - 0x000500c4, 0x0000000a, 0x0000011e, 0x0000010f, 0x0000011d, 0x000500c5, 0x0000000a, 0x0000011f, 0x0000011b, 0x0000011e, - 0x000500c4, 0x0000000a, 0x00000122, 0x00000116, 0x00000121, 0x000500c5, 0x0000000a, 0x00000123, 0x0000011f, 0x00000122, - 0x0004007c, 0x00000019, 0x00000127, 0x00000123, 0x000500b8, 0x00000006, 0x0000012a, 0x00000127, 0x00000129, 0x000500ba, - 0x00000006, 0x0000012d, 0x00000127, 0x0000012c, 0x000500a6, 0x00000006, 0x0000012e, 0x0000012a, 0x0000012d, 0x000300f7, - 0x00000130, 0x00000000, 0x000400fa, 0x0000012e, 0x0000012f, 0x00000130, 0x000200f8, 0x0000012f, 0x00050050, 0x0000001a, - 0x00000133, 0x000000f8, 0x00000127, 0x000200fe, 0x00000133, 0x000200f8, 0x00000130, 0x000200f9, 0x000000ea, 0x000200f8, - 0x000000ea, 0x0004003d, 0x0000000a, 0x00000135, 0x000000e3, 0x00050080, 0x0000000a, 0x00000136, 0x00000135, 0x00000042, - 0x0003003e, 0x000000e3, 0x00000136, 0x000200f9, 0x000000e7, 0x000200f8, 0x000000e9, 0x000200fe, 0x00000137, 0x00010038, + 0x00000000, 0x00040020, 0x0000000b, 0x00000007, 0x0000000a, 0x00090021, 0x0000000c, 0x00000002, 0x0000000b, 0x0000000b, + 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x00070021, 0x00000015, 0x00000002, 0x0000000b, 0x0000000b, 0x0000000b, + 0x0000000b, 0x00060021, 0x0000001c, 0x0000000a, 0x0000000b, 0x0000000b, 0x0000000b, 0x00030016, 0x00000022, 0x00000020, + 0x0004001e, 0x00000023, 0x0000000a, 0x00000022, 0x00050021, 0x00000024, 0x00000023, 0x0000000b, 0x0000000b, 0x0003001d, + 0x0000002a, 0x0000000a, 0x0003001e, 0x0000002b, 0x0000002a, 0x00040020, 0x0000002c, 0x00000002, 0x0000002b, 0x0004003b, + 0x0000002c, 0x0000002d, 0x00000002, 0x00040015, 0x0000002e, 0x00000020, 0x00000001, 0x0004002b, 0x0000002e, 0x0000002f, + 0x00000000, 0x00040020, 0x00000030, 0x00000002, 0x0000000a, 0x0003001d, 0x00000034, 0x0000000a, 0x0003001e, 0x00000035, + 0x00000034, 0x00040020, 0x00000036, 0x00000002, 0x00000035, 0x0004003b, 0x00000036, 0x00000037, 0x00000002, 0x0004002b, + 0x0000000a, 0x0000003a, 0x00000001, 0x0004002b, 0x0000000a, 0x0000003b, 0x00000000, 0x0004002b, 0x0000000a, 0x0000003e, + 0x00000006, 0x0003001d, 0x00000047, 0x0000000a, 0x0005001e, 0x00000048, 0x0000000a, 0x0000000a, 0x00000047, 0x00040020, + 0x00000049, 0x00000002, 0x00000048, 0x0004003b, 0x00000049, 0x0000004a, 0x00000002, 0x0004002b, 0x0000002e, 0x0000004b, + 0x00000001, 0x0004002b, 0x0000000a, 0x0000004d, 0x00000010, 0x0004002b, 0x0000002e, 0x0000005b, 0x00000002, 0x0004002b, + 0x0000000a, 0x00000060, 0x00000007, 0x0003001d, 0x00000062, 0x0000000a, 0x0003001e, 0x00000063, 0x00000062, 0x00040020, + 0x00000064, 0x00000002, 0x00000063, 0x0004003b, 0x00000064, 0x00000065, 0x00000002, 0x0004002b, 0x0000000a, 0x0000006a, + 0x00000008, 0x0004002b, 0x0000000a, 0x00000070, 0x00000009, 0x0004002b, 0x0000000a, 0x00000075, 0x0000000a, 0x0004002b, + 0x0000000a, 0x0000007a, 0x0000000b, 0x0004002b, 0x0000000a, 0x0000007f, 0x0000000c, 0x0004002b, 0x0000000a, 0x00000084, + 0x0000000d, 0x0004002b, 0x0000000a, 0x00000089, 0x0000000e, 0x00040017, 0x00000098, 0x0000002e, 0x00000003, 0x00040020, + 0x00000099, 0x00000007, 0x00000098, 0x00040017, 0x0000009b, 0x0000000a, 0x00000004, 0x0004002b, 0x0000000a, 0x0000009c, + 0x00000002, 0x0004001c, 0x0000009d, 0x0000000a, 0x0000009c, 0x0004001c, 0x0000009e, 0x0000000a, 0x0000009c, 0x00040017, + 0x0000009f, 0x0000002e, 0x00000004, 0x000b001e, 0x000000a0, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, + 0x0000000a, 0x0000009e, 0x0000009f, 0x0000009b, 0x0003001d, 0x000000a1, 0x000000a0, 0x0007001e, 0x000000a2, 0x0000009b, + 0x0000000a, 0x0000000a, 0x0000009d, 0x000000a1, 0x00040020, 0x000000a3, 0x00000002, 0x000000a2, 0x0004003b, 0x000000a3, + 0x000000a4, 0x00000002, 0x0004002b, 0x0000002e, 0x000000a5, 0x00000004, 0x0004002b, 0x0000002e, 0x000000a7, 0x00000007, + 0x00040020, 0x000000a8, 0x00000002, 0x0000009f, 0x00040017, 0x000000ac, 0x0000000a, 0x00000003, 0x00040020, 0x000000ad, + 0x00000007, 0x000000ac, 0x0004002b, 0x0000002e, 0x000000b0, 0x00000008, 0x00040020, 0x000000b1, 0x00000002, 0x0000009b, + 0x00040020, 0x000000bb, 0x00000007, 0x0000002e, 0x0004002b, 0x0000002e, 0x000000ea, 0x00000003, 0x0004002b, 0x0000002e, + 0x000000f9, 0x00000005, 0x00040015, 0x00000118, 0x00000008, 0x00000000, 0x0003001d, 0x00000119, 0x00000118, 0x0003001e, + 0x0000011a, 0x00000119, 0x00040020, 0x0000011b, 0x00000002, 0x0000011a, 0x0004003b, 0x0000011b, 0x0000011c, 0x00000002, + 0x00040020, 0x0000011e, 0x00000002, 0x00000118, 0x0004002b, 0x0000000a, 0x00000130, 0x00000003, 0x0004002b, 0x0000002e, + 0x0000013b, 0x00000010, 0x0004002b, 0x0000002e, 0x0000013f, 0x00000018, 0x00040020, 0x00000142, 0x00000007, 0x00000022, + 0x0004002b, 0x00000022, 0x00000147, 0x00000000, 0x0004002b, 0x00000022, 0x0000014a, 0x3f800000, 0x0005002c, 0x00000023, + 0x00000155, 0x0000003b, 0x00000147, 0x00040020, 0x00000159, 0x00000001, 0x000000ac, 0x0004003b, 0x00000159, 0x0000015a, + 0x00000001, 0x00040020, 0x0000015b, 0x00000001, 0x0000000a, 0x00040020, 0x0000017a, 0x00000007, 0x00000023, 0x00050036, + 0x00000002, 0x00000004, 0x00000000, 0x00000003, 0x000200f8, 0x00000005, 0x0004003b, 0x0000000b, 0x0000015e, 0x00000007, + 0x0004003b, 0x0000017a, 0x0000017b, 0x00000007, 0x0004003b, 0x0000000b, 0x0000017c, 0x00000007, 0x0004003b, 0x0000000b, + 0x0000017e, 0x00000007, 0x0004003b, 0x0000000b, 0x0000018d, 0x00000007, 0x0004003b, 0x0000000b, 0x0000018e, 0x00000007, + 0x0004003b, 0x0000000b, 0x0000018f, 0x00000007, 0x0004003b, 0x0000000b, 0x00000192, 0x00000007, 0x00050041, 0x0000015b, + 0x0000015c, 0x0000015a, 0x0000003b, 0x0004003d, 0x0000000a, 0x0000015d, 0x0000015c, 0x0003003e, 0x0000015e, 0x0000003b, + 0x000200f9, 0x0000015f, 0x000200f8, 0x0000015f, 0x000400f6, 0x00000161, 0x00000162, 0x00000000, 0x000200f9, 0x00000163, + 0x000200f8, 0x00000163, 0x0004003d, 0x0000000a, 0x00000164, 0x0000015e, 0x00050041, 0x00000030, 0x00000165, 0x000000a4, + 0x0000005b, 0x0004003d, 0x0000000a, 0x00000166, 0x00000165, 0x000500b0, 0x00000006, 0x00000167, 0x00000164, 0x00000166, + 0x000400fa, 0x00000167, 0x00000160, 0x00000161, 0x000200f8, 0x00000160, 0x0004003d, 0x0000000a, 0x00000169, 0x0000015e, + 0x00080041, 0x00000030, 0x0000016a, 0x000000a4, 0x000000a5, 0x00000169, 0x000000b0, 0x0000003b, 0x0004003d, 0x0000000a, + 0x0000016b, 0x0000016a, 0x00080041, 0x00000030, 0x0000016d, 0x000000a4, 0x000000a5, 0x00000169, 0x000000b0, 0x0000003a, + 0x0004003d, 0x0000000a, 0x0000016e, 0x0000016d, 0x00050084, 0x0000000a, 0x0000016f, 0x0000016b, 0x0000016e, 0x00080041, + 0x00000030, 0x00000171, 0x000000a4, 0x000000a5, 0x00000169, 0x000000b0, 0x0000009c, 0x0004003d, 0x0000000a, 0x00000172, + 0x00000171, 0x00050084, 0x0000000a, 0x00000173, 0x0000016f, 0x00000172, 0x000500ae, 0x00000006, 0x00000176, 0x0000015d, + 0x00000173, 0x000300f7, 0x00000178, 0x00000000, 0x000400fa, 0x00000176, 0x00000177, 0x00000178, 0x000200f8, 0x00000177, + 0x000200f9, 0x00000162, 0x000200f8, 0x00000178, 0x0003003e, 0x0000017c, 0x0000015d, 0x0004003d, 0x0000000a, 0x0000017f, + 0x0000015e, 0x0003003e, 0x0000017e, 0x0000017f, 0x00060039, 0x00000023, 0x00000180, 0x00000027, 0x0000017c, 0x0000017e, + 0x0003003e, 0x0000017b, 0x00000180, 0x00050041, 0x00000142, 0x00000181, 0x0000017b, 0x0000004b, 0x0004003d, 0x00000022, + 0x00000182, 0x00000181, 0x000500b8, 0x00000006, 0x00000183, 0x00000182, 0x00000147, 0x000400a8, 0x00000006, 0x00000184, + 0x00000183, 0x000300f7, 0x00000186, 0x00000000, 0x000400fa, 0x00000184, 0x00000185, 0x00000186, 0x000200f8, 0x00000185, + 0x00050041, 0x00000142, 0x00000187, 0x0000017b, 0x0000004b, 0x0004003d, 0x00000022, 0x00000188, 0x00000187, 0x000500ba, + 0x00000006, 0x00000189, 0x00000188, 0x0000014a, 0x000200f9, 0x00000186, 0x000200f8, 0x00000186, 0x000700f5, 0x00000006, + 0x0000018a, 0x00000183, 0x00000178, 0x00000189, 0x00000185, 0x000300f7, 0x0000018c, 0x00000000, 0x000400fa, 0x0000018a, + 0x0000018b, 0x0000018c, 0x000200f8, 0x0000018b, 0x0003003e, 0x0000018d, 0x00000060, 0x0003003e, 0x0000018e, 0x0000003a, + 0x00050041, 0x0000000b, 0x00000190, 0x0000017b, 0x0000002f, 0x0004003d, 0x0000000a, 0x00000191, 0x00000190, 0x0003003e, + 0x0000018f, 0x00000191, 0x0003003e, 0x00000192, 0x0000003b, 0x00080039, 0x00000002, 0x00000193, 0x0000001a, 0x0000018d, + 0x0000018e, 0x0000018f, 0x00000192, 0x000200f9, 0x0000018c, 0x000200f8, 0x0000018c, 0x000200f9, 0x00000162, 0x000200f8, + 0x00000162, 0x0004003d, 0x0000000a, 0x00000194, 0x0000015e, 0x00050080, 0x0000000a, 0x00000195, 0x00000194, 0x0000004b, + 0x0003003e, 0x0000015e, 0x00000195, 0x000200f9, 0x0000015f, 0x000200f8, 0x00000161, 0x000100fd, 0x00010038, 0x00050036, + 0x00000006, 0x00000008, 0x00000000, 0x00000007, 0x000200f8, 0x00000009, 0x00060041, 0x00000030, 0x00000031, 0x0000002d, + 0x0000002f, 0x0000002f, 0x0004003d, 0x0000000a, 0x00000032, 0x00000031, 0x00060041, 0x00000030, 0x00000039, 0x00000037, + 0x0000002f, 0x00000032, 0x000700ea, 0x0000000a, 0x0000003c, 0x00000039, 0x0000003a, 0x0000003b, 0x0000003a, 0x000500ae, + 0x00000006, 0x0000003f, 0x0000003c, 0x0000003e, 0x000200fe, 0x0000003f, 0x00010038, 0x00050036, 0x00000002, 0x00000013, + 0x00000000, 0x0000000c, 0x00030037, 0x0000000b, 0x0000000d, 0x00030037, 0x0000000b, 0x0000000e, 0x00030037, 0x0000000b, + 0x0000000f, 0x00030037, 0x0000000b, 0x00000010, 0x00030037, 0x0000000b, 0x00000011, 0x00030037, 0x0000000b, 0x00000012, + 0x000200f8, 0x00000014, 0x00040039, 0x00000006, 0x00000042, 0x00000008, 0x000300f7, 0x00000044, 0x00000000, 0x000400fa, + 0x00000042, 0x00000043, 0x00000044, 0x000200f8, 0x00000043, 0x000100fd, 0x000200f8, 0x00000044, 0x00050041, 0x00000030, + 0x0000004c, 0x0000004a, 0x0000004b, 0x000700ea, 0x0000000a, 0x0000004e, 0x0000004c, 0x0000003a, 0x0000003b, 0x0000004d, + 0x00050080, 0x0000000a, 0x00000052, 0x0000004e, 0x0000004d, 0x00050044, 0x0000000a, 0x00000053, 0x0000004a, 0x00000002, + 0x0004007c, 0x0000002e, 0x00000054, 0x00000053, 0x0004007c, 0x0000000a, 0x00000055, 0x00000054, 0x000500ac, 0x00000006, + 0x00000056, 0x00000052, 0x00000055, 0x000300f7, 0x00000059, 0x00000000, 0x000400fa, 0x00000056, 0x00000058, 0x00000059, + 0x000200f8, 0x00000058, 0x000100fd, 0x000200f8, 0x00000059, 0x00060041, 0x00000030, 0x0000005e, 0x0000004a, 0x0000005b, + 0x0000004e, 0x0003003e, 0x0000005e, 0x0000004d, 0x00050080, 0x0000000a, 0x00000061, 0x0000004e, 0x00000060, 0x00060041, + 0x00000030, 0x00000066, 0x00000065, 0x0000002f, 0x0000002f, 0x0004003d, 0x0000000a, 0x00000067, 0x00000066, 0x00060041, + 0x00000030, 0x00000068, 0x0000004a, 0x0000005b, 0x00000061, 0x0003003e, 0x00000068, 0x00000067, 0x00050080, 0x0000000a, + 0x0000006b, 0x0000004e, 0x0000006a, 0x00060041, 0x00000030, 0x0000006c, 0x0000002d, 0x0000002f, 0x0000002f, 0x0004003d, + 0x0000000a, 0x0000006d, 0x0000006c, 0x00060041, 0x00000030, 0x0000006e, 0x0000004a, 0x0000005b, 0x0000006b, 0x0003003e, + 0x0000006e, 0x0000006d, 0x00050080, 0x0000000a, 0x00000071, 0x0000004e, 0x00000070, 0x0004003d, 0x0000000a, 0x00000072, + 0x0000000d, 0x00060041, 0x00000030, 0x00000073, 0x0000004a, 0x0000005b, 0x00000071, 0x0003003e, 0x00000073, 0x00000072, + 0x00050080, 0x0000000a, 0x00000076, 0x0000004e, 0x00000075, 0x0004003d, 0x0000000a, 0x00000077, 0x0000000e, 0x00060041, + 0x00000030, 0x00000078, 0x0000004a, 0x0000005b, 0x00000076, 0x0003003e, 0x00000078, 0x00000077, 0x00050080, 0x0000000a, + 0x0000007b, 0x0000004e, 0x0000007a, 0x0004003d, 0x0000000a, 0x0000007c, 0x0000000f, 0x00060041, 0x00000030, 0x0000007d, + 0x0000004a, 0x0000005b, 0x0000007b, 0x0003003e, 0x0000007d, 0x0000007c, 0x00050080, 0x0000000a, 0x00000080, 0x0000004e, + 0x0000007f, 0x0004003d, 0x0000000a, 0x00000081, 0x00000010, 0x00060041, 0x00000030, 0x00000082, 0x0000004a, 0x0000005b, + 0x00000080, 0x0003003e, 0x00000082, 0x00000081, 0x00050080, 0x0000000a, 0x00000085, 0x0000004e, 0x00000084, 0x0004003d, + 0x0000000a, 0x00000086, 0x00000011, 0x00060041, 0x00000030, 0x00000087, 0x0000004a, 0x0000005b, 0x00000085, 0x0003003e, + 0x00000087, 0x00000086, 0x00050080, 0x0000000a, 0x0000008a, 0x0000004e, 0x00000089, 0x0004003d, 0x0000000a, 0x0000008b, + 0x00000012, 0x00060041, 0x00000030, 0x0000008c, 0x0000004a, 0x0000005b, 0x0000008a, 0x0003003e, 0x0000008c, 0x0000008b, + 0x000100fd, 0x00010038, 0x00050036, 0x00000002, 0x0000001a, 0x00000000, 0x00000015, 0x00030037, 0x0000000b, 0x00000016, + 0x00030037, 0x0000000b, 0x00000017, 0x00030037, 0x0000000b, 0x00000018, 0x00030037, 0x0000000b, 0x00000019, 0x000200f8, + 0x0000001b, 0x0004003b, 0x0000000b, 0x0000008d, 0x00000007, 0x0004003b, 0x0000000b, 0x0000008f, 0x00000007, 0x0004003b, + 0x0000000b, 0x00000091, 0x00000007, 0x0004003b, 0x0000000b, 0x00000093, 0x00000007, 0x0004003b, 0x0000000b, 0x00000095, + 0x00000007, 0x0004003b, 0x0000000b, 0x00000096, 0x00000007, 0x0004003d, 0x0000000a, 0x0000008e, 0x00000016, 0x0003003e, + 0x0000008d, 0x0000008e, 0x0004003d, 0x0000000a, 0x00000090, 0x00000017, 0x0003003e, 0x0000008f, 0x00000090, 0x0004003d, + 0x0000000a, 0x00000092, 0x00000018, 0x0003003e, 0x00000091, 0x00000092, 0x0004003d, 0x0000000a, 0x00000094, 0x00000019, + 0x0003003e, 0x00000093, 0x00000094, 0x0003003e, 0x00000095, 0x0000003b, 0x0003003e, 0x00000096, 0x0000003b, 0x000a0039, + 0x00000002, 0x00000097, 0x00000013, 0x0000008d, 0x0000008f, 0x00000091, 0x00000093, 0x00000095, 0x00000096, 0x000100fd, + 0x00010038, 0x00050036, 0x0000000a, 0x00000020, 0x00000000, 0x0000001c, 0x00030037, 0x0000000b, 0x0000001d, 0x00030037, + 0x0000000b, 0x0000001e, 0x00030037, 0x0000000b, 0x0000001f, 0x000200f8, 0x00000021, 0x0004003b, 0x00000099, 0x0000009a, + 0x00000007, 0x0004003b, 0x000000ad, 0x000000ae, 0x00000007, 0x0004003b, 0x00000099, 0x000000b5, 0x00000007, 0x0004003d, + 0x0000000a, 0x000000a6, 0x0000001e, 0x00070041, 0x000000a8, 0x000000a9, 0x000000a4, 0x000000a5, 0x000000a6, 0x000000a7, + 0x0004003d, 0x0000009f, 0x000000aa, 0x000000a9, 0x0008004f, 0x00000098, 0x000000ab, 0x000000aa, 0x000000aa, 0x00000000, + 0x00000001, 0x00000002, 0x0003003e, 0x0000009a, 0x000000ab, 0x0004003d, 0x0000000a, 0x000000af, 0x0000001e, 0x00070041, + 0x000000b1, 0x000000b2, 0x000000a4, 0x000000a5, 0x000000af, 0x000000b0, 0x0004003d, 0x0000009b, 0x000000b3, 0x000000b2, + 0x0008004f, 0x000000ac, 0x000000b4, 0x000000b3, 0x000000b3, 0x00000000, 0x00000001, 0x00000002, 0x0003003e, 0x000000ae, + 0x000000b4, 0x0004003d, 0x0000000a, 0x000000b6, 0x0000001d, 0x00050041, 0x0000000b, 0x000000b7, 0x000000ae, 0x0000003b, + 0x0004003d, 0x0000000a, 0x000000b8, 0x000000b7, 0x00050089, 0x0000000a, 0x000000b9, 0x000000b6, 0x000000b8, 0x0004007c, + 0x0000002e, 0x000000ba, 0x000000b9, 0x00050041, 0x000000bb, 0x000000bc, 0x0000009a, 0x0000003b, 0x0004003d, 0x0000002e, + 0x000000bd, 0x000000bc, 0x00050080, 0x0000002e, 0x000000be, 0x000000ba, 0x000000bd, 0x00050041, 0x000000bb, 0x000000bf, + 0x000000b5, 0x0000003b, 0x0003003e, 0x000000bf, 0x000000be, 0x0004003d, 0x0000000a, 0x000000c0, 0x0000001d, 0x00050041, + 0x0000000b, 0x000000c1, 0x000000ae, 0x0000003b, 0x0004003d, 0x0000000a, 0x000000c2, 0x000000c1, 0x00050086, 0x0000000a, + 0x000000c3, 0x000000c0, 0x000000c2, 0x00050041, 0x0000000b, 0x000000c4, 0x000000ae, 0x0000003b, 0x0004003d, 0x0000000a, + 0x000000c5, 0x000000c4, 0x00050041, 0x0000000b, 0x000000c6, 0x000000ae, 0x0000003a, 0x0004003d, 0x0000000a, 0x000000c7, + 0x000000c6, 0x00050084, 0x0000000a, 0x000000c8, 0x000000c5, 0x000000c7, 0x00050089, 0x0000000a, 0x000000c9, 0x000000c3, + 0x000000c8, 0x0004007c, 0x0000002e, 0x000000ca, 0x000000c9, 0x00050041, 0x000000bb, 0x000000cb, 0x0000009a, 0x0000003a, + 0x0004003d, 0x0000002e, 0x000000cc, 0x000000cb, 0x00050080, 0x0000002e, 0x000000cd, 0x000000ca, 0x000000cc, 0x00050041, + 0x000000bb, 0x000000ce, 0x000000b5, 0x0000003a, 0x0003003e, 0x000000ce, 0x000000cd, 0x0004003d, 0x0000000a, 0x000000cf, + 0x0000001d, 0x00050041, 0x0000000b, 0x000000d0, 0x000000ae, 0x0000003b, 0x0004003d, 0x0000000a, 0x000000d1, 0x000000d0, + 0x00050041, 0x0000000b, 0x000000d2, 0x000000ae, 0x0000003a, 0x0004003d, 0x0000000a, 0x000000d3, 0x000000d2, 0x00050084, + 0x0000000a, 0x000000d4, 0x000000d1, 0x000000d3, 0x00050086, 0x0000000a, 0x000000d5, 0x000000cf, 0x000000d4, 0x0004007c, + 0x0000002e, 0x000000d6, 0x000000d5, 0x00050041, 0x000000bb, 0x000000d7, 0x0000009a, 0x0000009c, 0x0004003d, 0x0000002e, + 0x000000d8, 0x000000d7, 0x00050080, 0x0000002e, 0x000000d9, 0x000000d6, 0x000000d8, 0x00050041, 0x000000bb, 0x000000da, + 0x000000b5, 0x0000009c, 0x0003003e, 0x000000da, 0x000000d9, 0x0004003d, 0x0000000a, 0x000000dc, 0x0000001e, 0x00070041, + 0x00000030, 0x000000dd, 0x000000a4, 0x000000a5, 0x000000dc, 0x0000002f, 0x0004003d, 0x0000000a, 0x000000de, 0x000000dd, + 0x00050041, 0x000000bb, 0x000000df, 0x000000b5, 0x0000003b, 0x0004003d, 0x0000002e, 0x000000e0, 0x000000df, 0x0004007c, + 0x0000000a, 0x000000e1, 0x000000e0, 0x00050041, 0x00000030, 0x000000e2, 0x000000a4, 0x0000004b, 0x0004003d, 0x0000000a, + 0x000000e3, 0x000000e2, 0x00050084, 0x0000000a, 0x000000e4, 0x000000e1, 0x000000e3, 0x00050080, 0x0000000a, 0x000000e5, + 0x000000de, 0x000000e4, 0x00050041, 0x000000bb, 0x000000e6, 0x000000b5, 0x0000003a, 0x0004003d, 0x0000002e, 0x000000e7, + 0x000000e6, 0x0004007c, 0x0000000a, 0x000000e8, 0x000000e7, 0x0004003d, 0x0000000a, 0x000000e9, 0x0000001e, 0x00070041, + 0x00000030, 0x000000eb, 0x000000a4, 0x000000a5, 0x000000e9, 0x000000ea, 0x0004003d, 0x0000000a, 0x000000ec, 0x000000eb, + 0x00050084, 0x0000000a, 0x000000ed, 0x000000e8, 0x000000ec, 0x00050080, 0x0000000a, 0x000000ee, 0x000000e5, 0x000000ed, + 0x00050041, 0x000000bb, 0x000000ef, 0x000000b5, 0x0000009c, 0x0004003d, 0x0000002e, 0x000000f0, 0x000000ef, 0x0004007c, + 0x0000000a, 0x000000f1, 0x000000f0, 0x0004003d, 0x0000000a, 0x000000f2, 0x0000001e, 0x00070041, 0x00000030, 0x000000f3, + 0x000000a4, 0x000000a5, 0x000000f2, 0x000000a5, 0x0004003d, 0x0000000a, 0x000000f4, 0x000000f3, 0x00050084, 0x0000000a, + 0x000000f5, 0x000000f1, 0x000000f4, 0x00050080, 0x0000000a, 0x000000f6, 0x000000ee, 0x000000f5, 0x0004003d, 0x0000000a, + 0x000000f7, 0x0000001f, 0x0004003d, 0x0000000a, 0x000000f8, 0x0000001e, 0x00070041, 0x00000030, 0x000000fa, 0x000000a4, + 0x000000a5, 0x000000f8, 0x000000f9, 0x0004003d, 0x0000000a, 0x000000fb, 0x000000fa, 0x00050084, 0x0000000a, 0x000000fc, + 0x000000f7, 0x000000fb, 0x00050080, 0x0000000a, 0x000000fd, 0x000000f6, 0x000000fc, 0x000200fe, 0x000000fd, 0x00010038, + 0x00050036, 0x00000023, 0x00000027, 0x00000000, 0x00000024, 0x00030037, 0x0000000b, 0x00000025, 0x00030037, 0x0000000b, + 0x00000026, 0x000200f8, 0x00000028, 0x0004003b, 0x0000000b, 0x00000101, 0x00000007, 0x0004003b, 0x0000000b, 0x00000110, + 0x00000007, 0x0004003b, 0x0000000b, 0x00000112, 0x00000007, 0x0004003b, 0x0000000b, 0x00000114, 0x00000007, 0x0004003d, + 0x0000000a, 0x00000102, 0x00000026, 0x00070041, 0x00000030, 0x00000103, 0x000000a4, 0x000000a5, 0x00000102, 0x0000004b, + 0x0004003d, 0x0000000a, 0x00000104, 0x00000103, 0x0003003e, 0x00000101, 0x00000104, 0x000200f9, 0x00000105, 0x000200f8, + 0x00000105, 0x000400f6, 0x00000107, 0x00000108, 0x00000000, 0x000200f9, 0x00000109, 0x000200f8, 0x00000109, 0x0004003d, + 0x0000000a, 0x0000010a, 0x00000101, 0x0004003d, 0x0000000a, 0x0000010b, 0x00000026, 0x00070041, 0x00000030, 0x0000010c, + 0x000000a4, 0x000000a5, 0x0000010b, 0x0000005b, 0x0004003d, 0x0000000a, 0x0000010d, 0x0000010c, 0x000500b0, 0x00000006, + 0x0000010e, 0x0000010a, 0x0000010d, 0x000400fa, 0x0000010e, 0x00000106, 0x00000107, 0x000200f8, 0x00000106, 0x0004003d, + 0x0000000a, 0x00000111, 0x00000025, 0x0003003e, 0x00000110, 0x00000111, 0x0004003d, 0x0000000a, 0x00000113, 0x00000026, + 0x0003003e, 0x00000112, 0x00000113, 0x0004003d, 0x0000000a, 0x00000115, 0x00000101, 0x0003003e, 0x00000114, 0x00000115, + 0x00070039, 0x0000000a, 0x00000116, 0x00000020, 0x00000110, 0x00000112, 0x00000114, 0x00060041, 0x0000011e, 0x0000011f, + 0x0000011c, 0x0000002f, 0x00000116, 0x0004003d, 0x00000118, 0x00000120, 0x0000011f, 0x00040071, 0x0000000a, 0x00000121, + 0x00000120, 0x00050080, 0x0000000a, 0x00000124, 0x00000116, 0x0000003a, 0x00060041, 0x0000011e, 0x00000125, 0x0000011c, + 0x0000002f, 0x00000124, 0x0004003d, 0x00000118, 0x00000126, 0x00000125, 0x00040071, 0x0000000a, 0x00000127, 0x00000126, + 0x00050080, 0x0000000a, 0x0000012a, 0x00000116, 0x0000009c, 0x00060041, 0x0000011e, 0x0000012b, 0x0000011c, 0x0000002f, + 0x0000012a, 0x0004003d, 0x00000118, 0x0000012c, 0x0000012b, 0x00040071, 0x0000000a, 0x0000012d, 0x0000012c, 0x00050080, + 0x0000000a, 0x00000131, 0x00000116, 0x00000130, 0x00060041, 0x0000011e, 0x00000132, 0x0000011c, 0x0000002f, 0x00000131, + 0x0004003d, 0x00000118, 0x00000133, 0x00000132, 0x00040071, 0x0000000a, 0x00000134, 0x00000133, 0x000500c4, 0x0000000a, + 0x00000138, 0x00000127, 0x000000b0, 0x000500c5, 0x0000000a, 0x00000139, 0x00000121, 0x00000138, 0x000500c4, 0x0000000a, + 0x0000013c, 0x0000012d, 0x0000013b, 0x000500c5, 0x0000000a, 0x0000013d, 0x00000139, 0x0000013c, 0x000500c4, 0x0000000a, + 0x00000140, 0x00000134, 0x0000013f, 0x000500c5, 0x0000000a, 0x00000141, 0x0000013d, 0x00000140, 0x0004007c, 0x00000022, + 0x00000145, 0x00000141, 0x000500b8, 0x00000006, 0x00000148, 0x00000145, 0x00000147, 0x000500ba, 0x00000006, 0x0000014b, + 0x00000145, 0x0000014a, 0x000500a6, 0x00000006, 0x0000014c, 0x00000148, 0x0000014b, 0x000300f7, 0x0000014e, 0x00000000, + 0x000400fa, 0x0000014c, 0x0000014d, 0x0000014e, 0x000200f8, 0x0000014d, 0x00050050, 0x00000023, 0x00000151, 0x00000116, + 0x00000145, 0x000200fe, 0x00000151, 0x000200f8, 0x0000014e, 0x000200f9, 0x00000108, 0x000200f8, 0x00000108, 0x0004003d, + 0x0000000a, 0x00000153, 0x00000101, 0x00050080, 0x0000000a, 0x00000154, 0x00000153, 0x0000004b, 0x0003003e, 0x00000101, + 0x00000154, 0x000200f9, 0x00000105, 0x000200f8, 0x00000107, 0x000200fe, 0x00000155, 0x00010038, }; diff --git a/layers/vulkan/generated/cmd_validation_count_buffer_vert.cpp b/layers/vulkan/generated/cmd_validation_count_buffer_vert.cpp new file mode 100644 index 00000000000..bef2fa3b82c --- /dev/null +++ b/layers/vulkan/generated/cmd_validation_count_buffer_vert.cpp @@ -0,0 +1,175 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See generate_spirv.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2021-2024 The Khronos Group Inc. + * Copyright (c) 2021-2024 Valve Corporation + * Copyright (c) 2021-2024 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************/ + +#include "cmd_validation_count_buffer_vert.h" + +// To view SPIR-V, copy contents of array and paste in https://www.khronos.org/spir/visualizer/ +[[maybe_unused]] const uint32_t cmd_validation_count_buffer_vert_size = 1458; +[[maybe_unused]] const uint32_t cmd_validation_count_buffer_vert[1458] = { + 0x07230203, 0x00010000, 0x0008000b, 0x000000d4, 0x00000000, 0x00020011, 0x00000001, 0x00020011, 0x0000000b, 0x0006000b, + 0x00000001, 0x4c534c47, 0x6474732e, 0x3035342e, 0x00000000, 0x0003000e, 0x00000000, 0x00000001, 0x0006000f, 0x00000000, + 0x00000004, 0x6e69616d, 0x00000000, 0x00000090, 0x00030003, 0x00000002, 0x000001c2, 0x00070004, 0x415f4c47, 0x675f4252, + 0x735f7570, 0x65646168, 0x6e695f72, 0x00343674, 0x000a0004, 0x475f4c47, 0x4c474f4f, 0x70635f45, 0x74735f70, 0x5f656c79, + 0x656e696c, 0x7269645f, 0x69746365, 0x00006576, 0x00080004, 0x475f4c47, 0x4c474f4f, 0x6e695f45, 0x64756c63, 0x69645f65, + 0x74636572, 0x00657669, 0x00040005, 0x00000004, 0x6e69616d, 0x00000000, 0x00090005, 0x00000008, 0x4378614d, 0x7245646d, + 0x73726f72, 0x6e756f43, 0x61655274, 0x64656863, 0x00000028, 0x000b0005, 0x00000013, 0x61757047, 0x676f4c76, 0x6f727245, + 0x75283472, 0x31753b31, 0x3b31753b, 0x753b3175, 0x31753b31, 0x0000003b, 0x00050005, 0x0000000d, 0x6f727265, 0x72675f72, + 0x0070756f, 0x00060005, 0x0000000e, 0x6f727265, 0x75735f72, 0x6f635f62, 0x00006564, 0x00040005, 0x0000000f, 0x61726170, + 0x00305f6d, 0x00040005, 0x00000010, 0x61726170, 0x00315f6d, 0x00040005, 0x00000011, 0x61726170, 0x00325f6d, 0x00040005, + 0x00000012, 0x61726170, 0x00335f6d, 0x00090005, 0x0000001a, 0x61757047, 0x676f4c76, 0x6f727245, 0x75283272, 0x31753b31, + 0x3b31753b, 0x003b3175, 0x00050005, 0x00000016, 0x6f727265, 0x72675f72, 0x0070756f, 0x00060005, 0x00000017, 0x6f727265, + 0x75735f72, 0x6f635f62, 0x00006564, 0x00040005, 0x00000018, 0x61726170, 0x00305f6d, 0x00040005, 0x00000019, 0x61726170, + 0x00315f6d, 0x00070005, 0x0000001e, 0x6f736552, 0x65637275, 0x65646e49, 0x66754278, 0x00726566, 0x00070006, 0x0000001e, + 0x00000000, 0x6f736572, 0x65637275, 0x646e695f, 0x00007865, 0x00030005, 0x00000020, 0x00000000, 0x00080005, 0x00000028, + 0x45646d43, 0x726f7272, 0x756f4373, 0x7542746e, 0x72656666, 0x00000000, 0x00080006, 0x00000028, 0x00000000, 0x5f646d63, + 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, 0x00030005, 0x0000002a, 0x00000000, 0x00050005, 0x0000003b, 0x6f727245, + 0x66754272, 0x00726566, 0x00050006, 0x0000003b, 0x00000000, 0x67616c66, 0x00000073, 0x00070006, 0x0000003b, 0x00000001, + 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, 0x00070006, 0x0000003b, 0x00000002, 0x6f727265, 0x625f7372, 0x65666675, + 0x00000072, 0x00030005, 0x0000003d, 0x00000000, 0x00070005, 0x00000056, 0x69746341, 0x6e496e6f, 0x42786564, 0x65666675, + 0x00000072, 0x00070006, 0x00000056, 0x00000000, 0x69746361, 0x695f6e6f, 0x7865646e, 0x00000000, 0x00030005, 0x00000058, + 0x00000000, 0x00040005, 0x00000080, 0x61726170, 0x0000006d, 0x00040005, 0x00000082, 0x61726170, 0x0000006d, 0x00040005, + 0x00000084, 0x61726170, 0x0000006d, 0x00040005, 0x00000086, 0x61726170, 0x0000006d, 0x00040005, 0x00000088, 0x61726170, + 0x0000006d, 0x00040005, 0x00000089, 0x61726170, 0x0000006d, 0x00060005, 0x0000008e, 0x505f6c67, 0x65567265, 0x78657472, + 0x00000000, 0x00060006, 0x0000008e, 0x00000000, 0x505f6c67, 0x7469736f, 0x006e6f69, 0x00070006, 0x0000008e, 0x00000001, + 0x505f6c67, 0x746e696f, 0x657a6953, 0x00000000, 0x00070006, 0x0000008e, 0x00000002, 0x435f6c67, 0x4470696c, 0x61747369, + 0x0065636e, 0x00070006, 0x0000008e, 0x00000003, 0x435f6c67, 0x446c6c75, 0x61747369, 0x0065636e, 0x00030005, 0x00000090, + 0x00000000, 0x00050005, 0x00000094, 0x6e756f43, 0x66754274, 0x00726566, 0x00060006, 0x00000094, 0x00000000, 0x77617264, + 0x756f635f, 0x0000746e, 0x00030005, 0x00000096, 0x00000000, 0x00070005, 0x000000a0, 0x6e756f43, 0x66754274, 0x50726566, + 0x44687375, 0x00617461, 0x00090006, 0x000000a0, 0x00000000, 0x77617264, 0x646d635f, 0x79625f73, 0x735f6574, 0x64697274, + 0x00000065, 0x00080006, 0x000000a0, 0x00000001, 0x77617264, 0x6675625f, 0x5f726566, 0x7366666f, 0x00007465, 0x00080006, + 0x000000a0, 0x00000002, 0x77617264, 0x6675625f, 0x5f726566, 0x657a6973, 0x00000000, 0x00080006, 0x000000a0, 0x00000003, + 0x77617264, 0x646d635f, 0x7479625f, 0x69735f65, 0x0000657a, 0x000d0006, 0x000000a0, 0x00000004, 0x69766564, 0x6c5f6563, + 0x74696d69, 0x78616d5f, 0x6172645f, 0x6e695f77, 0x65726964, 0x635f7463, 0x746e756f, 0x00000000, 0x00060005, 0x000000a1, + 0x68737550, 0x736e6f43, 0x746e6174, 0x00000073, 0x00040006, 0x000000a1, 0x00000000, 0x00006370, 0x00030005, 0x000000a3, + 0x00000000, 0x00040005, 0x000000bc, 0x61726170, 0x0000006d, 0x00040005, 0x000000bd, 0x61726170, 0x0000006d, 0x00040005, + 0x000000be, 0x61726170, 0x0000006d, 0x00040005, 0x000000c1, 0x61726170, 0x0000006d, 0x00040005, 0x000000cd, 0x61726170, + 0x0000006d, 0x00040005, 0x000000ce, 0x61726170, 0x0000006d, 0x00040005, 0x000000cf, 0x61726170, 0x0000006d, 0x00040005, + 0x000000d2, 0x61726170, 0x0000006d, 0x00040047, 0x0000001d, 0x00000006, 0x00000004, 0x00030047, 0x0000001e, 0x00000003, + 0x00040048, 0x0000001e, 0x00000000, 0x00000018, 0x00050048, 0x0000001e, 0x00000000, 0x00000023, 0x00000000, 0x00040047, + 0x00000020, 0x00000021, 0x00000002, 0x00040047, 0x00000020, 0x00000022, 0x00000000, 0x00040047, 0x00000027, 0x00000006, + 0x00000004, 0x00030047, 0x00000028, 0x00000003, 0x00050048, 0x00000028, 0x00000000, 0x00000023, 0x00000000, 0x00040047, + 0x0000002a, 0x00000021, 0x00000003, 0x00040047, 0x0000002a, 0x00000022, 0x00000000, 0x00040047, 0x0000003a, 0x00000006, + 0x00000004, 0x00030047, 0x0000003b, 0x00000003, 0x00050048, 0x0000003b, 0x00000000, 0x00000023, 0x00000000, 0x00050048, + 0x0000003b, 0x00000001, 0x00000023, 0x00000004, 0x00050048, 0x0000003b, 0x00000002, 0x00000023, 0x00000008, 0x00040047, + 0x0000003d, 0x00000021, 0x00000000, 0x00040047, 0x0000003d, 0x00000022, 0x00000000, 0x00040047, 0x00000055, 0x00000006, + 0x00000004, 0x00030047, 0x00000056, 0x00000003, 0x00040048, 0x00000056, 0x00000000, 0x00000018, 0x00050048, 0x00000056, + 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000058, 0x00000021, 0x00000001, 0x00040047, 0x00000058, 0x00000022, + 0x00000000, 0x00030047, 0x0000008e, 0x00000002, 0x00050048, 0x0000008e, 0x00000000, 0x0000000b, 0x00000000, 0x00050048, + 0x0000008e, 0x00000001, 0x0000000b, 0x00000001, 0x00050048, 0x0000008e, 0x00000002, 0x0000000b, 0x00000003, 0x00050048, + 0x0000008e, 0x00000003, 0x0000000b, 0x00000004, 0x00030047, 0x00000094, 0x00000003, 0x00040048, 0x00000094, 0x00000000, + 0x00000018, 0x00050048, 0x00000094, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000096, 0x00000021, 0x00000001, + 0x00040047, 0x00000096, 0x00000022, 0x00000001, 0x00050048, 0x000000a0, 0x00000000, 0x00000023, 0x00000000, 0x00050048, + 0x000000a0, 0x00000001, 0x00000023, 0x00000008, 0x00050048, 0x000000a0, 0x00000002, 0x00000023, 0x00000010, 0x00050048, + 0x000000a0, 0x00000003, 0x00000023, 0x00000018, 0x00050048, 0x000000a0, 0x00000004, 0x00000023, 0x0000001c, 0x00030047, + 0x000000a1, 0x00000002, 0x00050048, 0x000000a1, 0x00000000, 0x00000023, 0x00000000, 0x00020013, 0x00000002, 0x00030021, + 0x00000003, 0x00000002, 0x00020014, 0x00000006, 0x00030021, 0x00000007, 0x00000006, 0x00040015, 0x0000000a, 0x00000020, + 0x00000000, 0x00040020, 0x0000000b, 0x00000007, 0x0000000a, 0x00090021, 0x0000000c, 0x00000002, 0x0000000b, 0x0000000b, + 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x00070021, 0x00000015, 0x00000002, 0x0000000b, 0x0000000b, 0x0000000b, + 0x0000000b, 0x0003001d, 0x0000001d, 0x0000000a, 0x0003001e, 0x0000001e, 0x0000001d, 0x00040020, 0x0000001f, 0x00000002, + 0x0000001e, 0x0004003b, 0x0000001f, 0x00000020, 0x00000002, 0x00040015, 0x00000021, 0x00000020, 0x00000001, 0x0004002b, + 0x00000021, 0x00000022, 0x00000000, 0x00040020, 0x00000023, 0x00000002, 0x0000000a, 0x0003001d, 0x00000027, 0x0000000a, + 0x0003001e, 0x00000028, 0x00000027, 0x00040020, 0x00000029, 0x00000002, 0x00000028, 0x0004003b, 0x00000029, 0x0000002a, + 0x00000002, 0x0004002b, 0x0000000a, 0x0000002d, 0x00000001, 0x0004002b, 0x0000000a, 0x0000002e, 0x00000000, 0x0004002b, + 0x0000000a, 0x00000031, 0x00000006, 0x0003001d, 0x0000003a, 0x0000000a, 0x0005001e, 0x0000003b, 0x0000000a, 0x0000000a, + 0x0000003a, 0x00040020, 0x0000003c, 0x00000002, 0x0000003b, 0x0004003b, 0x0000003c, 0x0000003d, 0x00000002, 0x0004002b, + 0x00000021, 0x0000003e, 0x00000001, 0x0004002b, 0x0000000a, 0x00000040, 0x00000010, 0x0004002b, 0x00000021, 0x0000004e, + 0x00000002, 0x0004002b, 0x0000000a, 0x00000053, 0x00000007, 0x0003001d, 0x00000055, 0x0000000a, 0x0003001e, 0x00000056, + 0x00000055, 0x00040020, 0x00000057, 0x00000002, 0x00000056, 0x0004003b, 0x00000057, 0x00000058, 0x00000002, 0x0004002b, + 0x0000000a, 0x0000005d, 0x00000008, 0x0004002b, 0x0000000a, 0x00000063, 0x00000009, 0x0004002b, 0x0000000a, 0x00000068, + 0x0000000a, 0x0004002b, 0x0000000a, 0x0000006d, 0x0000000b, 0x0004002b, 0x0000000a, 0x00000072, 0x0000000c, 0x0004002b, + 0x0000000a, 0x00000077, 0x0000000d, 0x0004002b, 0x0000000a, 0x0000007c, 0x0000000e, 0x00030016, 0x0000008b, 0x00000020, + 0x00040017, 0x0000008c, 0x0000008b, 0x00000004, 0x0004001c, 0x0000008d, 0x0000008b, 0x0000002d, 0x0006001e, 0x0000008e, + 0x0000008c, 0x0000008b, 0x0000008d, 0x0000008d, 0x00040020, 0x0000008f, 0x00000003, 0x0000008e, 0x0004003b, 0x0000008f, + 0x00000090, 0x00000003, 0x0004002b, 0x0000008b, 0x00000091, 0x3f800000, 0x00040020, 0x00000092, 0x00000003, 0x0000008b, + 0x0003001e, 0x00000094, 0x0000000a, 0x00040020, 0x00000095, 0x00000002, 0x00000094, 0x0004003b, 0x00000095, 0x00000096, + 0x00000002, 0x00040015, 0x0000009d, 0x00000040, 0x00000000, 0x0007001e, 0x000000a0, 0x0000000a, 0x0000009d, 0x0000009d, + 0x0000000a, 0x0000000a, 0x0003001e, 0x000000a1, 0x000000a0, 0x00040020, 0x000000a2, 0x00000009, 0x000000a1, 0x0004003b, + 0x000000a2, 0x000000a3, 0x00000009, 0x00040020, 0x000000a4, 0x00000009, 0x0000000a, 0x00040020, 0x000000ac, 0x00000009, + 0x0000009d, 0x0004002b, 0x00000021, 0x000000b0, 0x00000003, 0x0004002b, 0x0000000a, 0x000000bb, 0x00000004, 0x0004002b, + 0x00000021, 0x000000c6, 0x00000004, 0x0004002b, 0x0000000a, 0x000000cc, 0x00000002, 0x00050036, 0x00000002, 0x00000004, + 0x00000000, 0x00000003, 0x000200f8, 0x00000005, 0x0004003b, 0x0000000b, 0x000000bc, 0x00000007, 0x0004003b, 0x0000000b, + 0x000000bd, 0x00000007, 0x0004003b, 0x0000000b, 0x000000be, 0x00000007, 0x0004003b, 0x0000000b, 0x000000c1, 0x00000007, + 0x0004003b, 0x0000000b, 0x000000cd, 0x00000007, 0x0004003b, 0x0000000b, 0x000000ce, 0x00000007, 0x0004003b, 0x0000000b, + 0x000000cf, 0x00000007, 0x0004003b, 0x0000000b, 0x000000d2, 0x00000007, 0x00050041, 0x00000092, 0x00000093, 0x00000090, + 0x0000003e, 0x0003003e, 0x00000093, 0x00000091, 0x00050041, 0x00000023, 0x00000097, 0x00000096, 0x00000022, 0x0004003d, + 0x0000000a, 0x00000098, 0x00000097, 0x000500aa, 0x00000006, 0x00000099, 0x00000098, 0x0000002e, 0x000300f7, 0x0000009b, + 0x00000000, 0x000400fa, 0x00000099, 0x0000009a, 0x0000009b, 0x000200f8, 0x0000009a, 0x000100fd, 0x000200f8, 0x0000009b, + 0x00060041, 0x000000a4, 0x000000a5, 0x000000a3, 0x00000022, 0x00000022, 0x0004003d, 0x0000000a, 0x000000a6, 0x000000a5, + 0x00050041, 0x00000023, 0x000000a7, 0x00000096, 0x00000022, 0x0004003d, 0x0000000a, 0x000000a8, 0x000000a7, 0x00050082, + 0x0000000a, 0x000000a9, 0x000000a8, 0x0000002d, 0x00050084, 0x0000000a, 0x000000aa, 0x000000a6, 0x000000a9, 0x00040071, + 0x0000009d, 0x000000ab, 0x000000aa, 0x00060041, 0x000000ac, 0x000000ad, 0x000000a3, 0x00000022, 0x0000003e, 0x0004003d, + 0x0000009d, 0x000000ae, 0x000000ad, 0x00050080, 0x0000009d, 0x000000af, 0x000000ab, 0x000000ae, 0x00060041, 0x000000a4, + 0x000000b1, 0x000000a3, 0x00000022, 0x000000b0, 0x0004003d, 0x0000000a, 0x000000b2, 0x000000b1, 0x00040071, 0x0000009d, + 0x000000b3, 0x000000b2, 0x00050080, 0x0000009d, 0x000000b4, 0x000000af, 0x000000b3, 0x00060041, 0x000000ac, 0x000000b6, + 0x000000a3, 0x00000022, 0x0000004e, 0x0004003d, 0x0000009d, 0x000000b7, 0x000000b6, 0x000500ac, 0x00000006, 0x000000b8, + 0x000000b4, 0x000000b7, 0x000300f7, 0x000000ba, 0x00000000, 0x000400fa, 0x000000b8, 0x000000b9, 0x000000c3, 0x000200f8, + 0x000000b9, 0x0003003e, 0x000000bc, 0x000000bb, 0x0003003e, 0x000000bd, 0x0000002d, 0x00050041, 0x00000023, 0x000000bf, + 0x00000096, 0x00000022, 0x0004003d, 0x0000000a, 0x000000c0, 0x000000bf, 0x0003003e, 0x000000be, 0x000000c0, 0x0003003e, + 0x000000c1, 0x0000002e, 0x00080039, 0x00000002, 0x000000c2, 0x0000001a, 0x000000bc, 0x000000bd, 0x000000be, 0x000000c1, + 0x000200f9, 0x000000ba, 0x000200f8, 0x000000c3, 0x00050041, 0x00000023, 0x000000c4, 0x00000096, 0x00000022, 0x0004003d, + 0x0000000a, 0x000000c5, 0x000000c4, 0x00060041, 0x000000a4, 0x000000c7, 0x000000a3, 0x00000022, 0x000000c6, 0x0004003d, + 0x0000000a, 0x000000c8, 0x000000c7, 0x000500ac, 0x00000006, 0x000000c9, 0x000000c5, 0x000000c8, 0x000300f7, 0x000000cb, + 0x00000000, 0x000400fa, 0x000000c9, 0x000000ca, 0x000000cb, 0x000200f8, 0x000000ca, 0x0003003e, 0x000000cd, 0x000000bb, + 0x0003003e, 0x000000ce, 0x000000cc, 0x00050041, 0x00000023, 0x000000d0, 0x00000096, 0x00000022, 0x0004003d, 0x0000000a, + 0x000000d1, 0x000000d0, 0x0003003e, 0x000000cf, 0x000000d1, 0x0003003e, 0x000000d2, 0x0000002e, 0x00080039, 0x00000002, + 0x000000d3, 0x0000001a, 0x000000cd, 0x000000ce, 0x000000cf, 0x000000d2, 0x000200f9, 0x000000cb, 0x000200f8, 0x000000cb, + 0x000200f9, 0x000000ba, 0x000200f8, 0x000000ba, 0x000100fd, 0x00010038, 0x00050036, 0x00000006, 0x00000008, 0x00000000, + 0x00000007, 0x000200f8, 0x00000009, 0x00060041, 0x00000023, 0x00000024, 0x00000020, 0x00000022, 0x00000022, 0x0004003d, + 0x0000000a, 0x00000025, 0x00000024, 0x00060041, 0x00000023, 0x0000002c, 0x0000002a, 0x00000022, 0x00000025, 0x000700ea, + 0x0000000a, 0x0000002f, 0x0000002c, 0x0000002d, 0x0000002e, 0x0000002d, 0x000500ae, 0x00000006, 0x00000032, 0x0000002f, + 0x00000031, 0x000200fe, 0x00000032, 0x00010038, 0x00050036, 0x00000002, 0x00000013, 0x00000000, 0x0000000c, 0x00030037, + 0x0000000b, 0x0000000d, 0x00030037, 0x0000000b, 0x0000000e, 0x00030037, 0x0000000b, 0x0000000f, 0x00030037, 0x0000000b, + 0x00000010, 0x00030037, 0x0000000b, 0x00000011, 0x00030037, 0x0000000b, 0x00000012, 0x000200f8, 0x00000014, 0x00040039, + 0x00000006, 0x00000035, 0x00000008, 0x000300f7, 0x00000037, 0x00000000, 0x000400fa, 0x00000035, 0x00000036, 0x00000037, + 0x000200f8, 0x00000036, 0x000100fd, 0x000200f8, 0x00000037, 0x00050041, 0x00000023, 0x0000003f, 0x0000003d, 0x0000003e, + 0x000700ea, 0x0000000a, 0x00000041, 0x0000003f, 0x0000002d, 0x0000002e, 0x00000040, 0x00050080, 0x0000000a, 0x00000045, + 0x00000041, 0x00000040, 0x00050044, 0x0000000a, 0x00000046, 0x0000003d, 0x00000002, 0x0004007c, 0x00000021, 0x00000047, + 0x00000046, 0x0004007c, 0x0000000a, 0x00000048, 0x00000047, 0x000500ac, 0x00000006, 0x00000049, 0x00000045, 0x00000048, + 0x000300f7, 0x0000004c, 0x00000000, 0x000400fa, 0x00000049, 0x0000004b, 0x0000004c, 0x000200f8, 0x0000004b, 0x000100fd, + 0x000200f8, 0x0000004c, 0x00060041, 0x00000023, 0x00000051, 0x0000003d, 0x0000004e, 0x00000041, 0x0003003e, 0x00000051, + 0x00000040, 0x00050080, 0x0000000a, 0x00000054, 0x00000041, 0x00000053, 0x00060041, 0x00000023, 0x00000059, 0x00000058, + 0x00000022, 0x00000022, 0x0004003d, 0x0000000a, 0x0000005a, 0x00000059, 0x00060041, 0x00000023, 0x0000005b, 0x0000003d, + 0x0000004e, 0x00000054, 0x0003003e, 0x0000005b, 0x0000005a, 0x00050080, 0x0000000a, 0x0000005e, 0x00000041, 0x0000005d, + 0x00060041, 0x00000023, 0x0000005f, 0x00000020, 0x00000022, 0x00000022, 0x0004003d, 0x0000000a, 0x00000060, 0x0000005f, + 0x00060041, 0x00000023, 0x00000061, 0x0000003d, 0x0000004e, 0x0000005e, 0x0003003e, 0x00000061, 0x00000060, 0x00050080, + 0x0000000a, 0x00000064, 0x00000041, 0x00000063, 0x0004003d, 0x0000000a, 0x00000065, 0x0000000d, 0x00060041, 0x00000023, + 0x00000066, 0x0000003d, 0x0000004e, 0x00000064, 0x0003003e, 0x00000066, 0x00000065, 0x00050080, 0x0000000a, 0x00000069, + 0x00000041, 0x00000068, 0x0004003d, 0x0000000a, 0x0000006a, 0x0000000e, 0x00060041, 0x00000023, 0x0000006b, 0x0000003d, + 0x0000004e, 0x00000069, 0x0003003e, 0x0000006b, 0x0000006a, 0x00050080, 0x0000000a, 0x0000006e, 0x00000041, 0x0000006d, + 0x0004003d, 0x0000000a, 0x0000006f, 0x0000000f, 0x00060041, 0x00000023, 0x00000070, 0x0000003d, 0x0000004e, 0x0000006e, + 0x0003003e, 0x00000070, 0x0000006f, 0x00050080, 0x0000000a, 0x00000073, 0x00000041, 0x00000072, 0x0004003d, 0x0000000a, + 0x00000074, 0x00000010, 0x00060041, 0x00000023, 0x00000075, 0x0000003d, 0x0000004e, 0x00000073, 0x0003003e, 0x00000075, + 0x00000074, 0x00050080, 0x0000000a, 0x00000078, 0x00000041, 0x00000077, 0x0004003d, 0x0000000a, 0x00000079, 0x00000011, + 0x00060041, 0x00000023, 0x0000007a, 0x0000003d, 0x0000004e, 0x00000078, 0x0003003e, 0x0000007a, 0x00000079, 0x00050080, + 0x0000000a, 0x0000007d, 0x00000041, 0x0000007c, 0x0004003d, 0x0000000a, 0x0000007e, 0x00000012, 0x00060041, 0x00000023, + 0x0000007f, 0x0000003d, 0x0000004e, 0x0000007d, 0x0003003e, 0x0000007f, 0x0000007e, 0x000100fd, 0x00010038, 0x00050036, + 0x00000002, 0x0000001a, 0x00000000, 0x00000015, 0x00030037, 0x0000000b, 0x00000016, 0x00030037, 0x0000000b, 0x00000017, + 0x00030037, 0x0000000b, 0x00000018, 0x00030037, 0x0000000b, 0x00000019, 0x000200f8, 0x0000001b, 0x0004003b, 0x0000000b, + 0x00000080, 0x00000007, 0x0004003b, 0x0000000b, 0x00000082, 0x00000007, 0x0004003b, 0x0000000b, 0x00000084, 0x00000007, + 0x0004003b, 0x0000000b, 0x00000086, 0x00000007, 0x0004003b, 0x0000000b, 0x00000088, 0x00000007, 0x0004003b, 0x0000000b, + 0x00000089, 0x00000007, 0x0004003d, 0x0000000a, 0x00000081, 0x00000016, 0x0003003e, 0x00000080, 0x00000081, 0x0004003d, + 0x0000000a, 0x00000083, 0x00000017, 0x0003003e, 0x00000082, 0x00000083, 0x0004003d, 0x0000000a, 0x00000085, 0x00000018, + 0x0003003e, 0x00000084, 0x00000085, 0x0004003d, 0x0000000a, 0x00000087, 0x00000019, 0x0003003e, 0x00000086, 0x00000087, + 0x0003003e, 0x00000088, 0x0000002e, 0x0003003e, 0x00000089, 0x0000002e, 0x000a0039, 0x00000002, 0x0000008a, 0x00000013, + 0x00000080, 0x00000082, 0x00000084, 0x00000086, 0x00000088, 0x00000089, 0x000100fd, 0x00010038, +}; diff --git a/layers/vulkan/generated/cmd_validation_draw_vert.h b/layers/vulkan/generated/cmd_validation_count_buffer_vert.h similarity index 90% rename from layers/vulkan/generated/cmd_validation_draw_vert.h rename to layers/vulkan/generated/cmd_validation_count_buffer_vert.h index 10935fa7f88..fddd3a71252 100644 --- a/layers/vulkan/generated/cmd_validation_draw_vert.h +++ b/layers/vulkan/generated/cmd_validation_count_buffer_vert.h @@ -26,5 +26,5 @@ #include // To view SPIR-V, copy contents of array and paste in https://www.khronos.org/spir/visualizer/ -extern const uint32_t cmd_validation_draw_vert_size; -extern const uint32_t cmd_validation_draw_vert[]; +extern const uint32_t cmd_validation_count_buffer_vert_size; +extern const uint32_t cmd_validation_count_buffer_vert[]; diff --git a/layers/vulkan/generated/cmd_validation_dispatch_comp.cpp b/layers/vulkan/generated/cmd_validation_dispatch_comp.cpp index 1775283740c..1b44d59c2a2 100644 --- a/layers/vulkan/generated/cmd_validation_dispatch_comp.cpp +++ b/layers/vulkan/generated/cmd_validation_dispatch_comp.cpp @@ -24,118 +24,139 @@ #include "cmd_validation_dispatch_comp.h" // To view SPIR-V, copy contents of array and paste in https://www.khronos.org/spir/visualizer/ -[[maybe_unused]] const uint32_t cmd_validation_dispatch_comp_size = 1112; -[[maybe_unused]] const uint32_t cmd_validation_dispatch_comp[1112] = { - 0x07230203, 0x00010000, 0x0008000b, 0x000000b0, 0x00000000, 0x00020011, 0x00000001, 0x0006000b, 0x00000001, 0x4c534c47, +[[maybe_unused]] const uint32_t cmd_validation_dispatch_comp_size = 1330; +[[maybe_unused]] const uint32_t cmd_validation_dispatch_comp[1330] = { + 0x07230203, 0x00010000, 0x0008000b, 0x000000ce, 0x00000000, 0x00020011, 0x00000001, 0x0006000b, 0x00000001, 0x4c534c47, 0x6474732e, 0x3035342e, 0x00000000, 0x0003000e, 0x00000000, 0x00000001, 0x0005000f, 0x00000005, 0x00000004, 0x6e69616d, 0x00000000, 0x00060010, 0x00000004, 0x00000011, 0x00000001, 0x00000001, 0x00000001, 0x00030003, 0x00000002, 0x000001c2, 0x000a0004, 0x475f4c47, 0x4c474f4f, 0x70635f45, 0x74735f70, 0x5f656c79, 0x656e696c, 0x7269645f, 0x69746365, 0x00006576, 0x00080004, 0x475f4c47, 0x4c474f4f, 0x6e695f45, 0x64756c63, 0x69645f65, 0x74636572, 0x00657669, 0x00040005, 0x00000004, 0x6e69616d, 0x00000000, 0x00090005, 0x00000008, 0x4378614d, 0x7245646d, 0x73726f72, 0x6e756f43, 0x61655274, 0x64656863, - 0x00000028, 0x00090005, 0x00000011, 0x61757047, 0x676f4c76, 0x6f727245, 0x31752872, 0x3b31753b, 0x753b3175, 0x00003b31, - 0x00050005, 0x0000000d, 0x6f727265, 0x72675f72, 0x0070756f, 0x00060005, 0x0000000e, 0x6f727265, 0x75735f72, 0x6f635f62, - 0x00006564, 0x00040005, 0x0000000f, 0x61726170, 0x00305f6d, 0x00040005, 0x00000010, 0x61726170, 0x00315f6d, 0x00070005, - 0x00000015, 0x6f736552, 0x65637275, 0x65646e49, 0x66754278, 0x00726566, 0x00070006, 0x00000015, 0x00000000, 0x6f736572, - 0x65637275, 0x646e695f, 0x00007865, 0x00030005, 0x00000017, 0x00000000, 0x00080005, 0x0000001f, 0x45646d43, 0x726f7272, - 0x756f4373, 0x7542746e, 0x72656666, 0x00000000, 0x00080006, 0x0000001f, 0x00000000, 0x5f646d63, 0x6f727265, 0x635f7372, - 0x746e756f, 0x00000000, 0x00030005, 0x00000021, 0x00000000, 0x00050005, 0x00000032, 0x6f727245, 0x66754272, 0x00726566, - 0x00050006, 0x00000032, 0x00000000, 0x67616c66, 0x00000073, 0x00070006, 0x00000032, 0x00000001, 0x6f727265, 0x635f7372, - 0x746e756f, 0x00000000, 0x00070006, 0x00000032, 0x00000002, 0x6f727265, 0x625f7372, 0x65666675, 0x00000072, 0x00030005, - 0x00000034, 0x00000000, 0x00070005, 0x0000004d, 0x69746341, 0x6e496e6f, 0x42786564, 0x65666675, 0x00000072, 0x00070006, - 0x0000004d, 0x00000000, 0x69746361, 0x695f6e6f, 0x7865646e, 0x00000000, 0x00030005, 0x0000004f, 0x00000000, 0x00060005, - 0x0000006f, 0x69646e49, 0x74636572, 0x66667542, 0x00007265, 0x00070006, 0x0000006f, 0x00000000, 0x69646e69, 0x74636572, - 0x6675625f, 0x00726566, 0x00030005, 0x00000071, 0x00000000, 0x00050005, 0x00000072, 0x66696e55, 0x496d726f, 0x006f666e, - 0x00050006, 0x00000072, 0x00000000, 0x696d696c, 0x00785f74, 0x00050006, 0x00000072, 0x00000001, 0x696d696c, 0x00795f74, - 0x00050006, 0x00000072, 0x00000002, 0x696d696c, 0x007a5f74, 0x00080006, 0x00000072, 0x00000003, 0x69646e69, 0x74636572, - 0x6f5f785f, 0x65736666, 0x00000074, 0x00030005, 0x00000074, 0x00000000, 0x00040005, 0x0000008f, 0x61726170, 0x0000006d, - 0x00040005, 0x00000090, 0x61726170, 0x0000006d, 0x00040005, 0x00000091, 0x61726170, 0x0000006d, 0x00040005, 0x00000093, - 0x61726170, 0x0000006d, 0x00040005, 0x0000009c, 0x61726170, 0x0000006d, 0x00040005, 0x0000009d, 0x61726170, 0x0000006d, - 0x00040005, 0x0000009e, 0x61726170, 0x0000006d, 0x00040005, 0x000000a0, 0x61726170, 0x0000006d, 0x00040005, 0x000000aa, - 0x61726170, 0x0000006d, 0x00040005, 0x000000ab, 0x61726170, 0x0000006d, 0x00040005, 0x000000ac, 0x61726170, 0x0000006d, - 0x00040005, 0x000000ae, 0x61726170, 0x0000006d, 0x00040047, 0x00000014, 0x00000006, 0x00000004, 0x00030047, 0x00000015, - 0x00000003, 0x00050048, 0x00000015, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000017, 0x00000021, 0x00000002, - 0x00040047, 0x00000017, 0x00000022, 0x00000000, 0x00040047, 0x0000001e, 0x00000006, 0x00000004, 0x00030047, 0x0000001f, - 0x00000003, 0x00050048, 0x0000001f, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000021, 0x00000021, 0x00000003, - 0x00040047, 0x00000021, 0x00000022, 0x00000000, 0x00040047, 0x00000031, 0x00000006, 0x00000004, 0x00030047, 0x00000032, - 0x00000003, 0x00050048, 0x00000032, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x00000032, 0x00000001, 0x00000023, - 0x00000004, 0x00050048, 0x00000032, 0x00000002, 0x00000023, 0x00000008, 0x00040047, 0x00000034, 0x00000021, 0x00000000, - 0x00040047, 0x00000034, 0x00000022, 0x00000000, 0x00040047, 0x0000004c, 0x00000006, 0x00000004, 0x00030047, 0x0000004d, - 0x00000003, 0x00050048, 0x0000004d, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x0000004f, 0x00000021, 0x00000001, - 0x00040047, 0x0000004f, 0x00000022, 0x00000000, 0x00040047, 0x0000006e, 0x00000006, 0x00000004, 0x00030047, 0x0000006f, - 0x00000003, 0x00050048, 0x0000006f, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000071, 0x00000021, 0x00000000, - 0x00040047, 0x00000071, 0x00000022, 0x00000001, 0x00030047, 0x00000072, 0x00000002, 0x00050048, 0x00000072, 0x00000000, - 0x00000023, 0x00000000, 0x00050048, 0x00000072, 0x00000001, 0x00000023, 0x00000004, 0x00050048, 0x00000072, 0x00000002, - 0x00000023, 0x00000008, 0x00050048, 0x00000072, 0x00000003, 0x00000023, 0x0000000c, 0x00020013, 0x00000002, 0x00030021, + 0x00000028, 0x000b0005, 0x00000013, 0x61757047, 0x676f4c76, 0x6f727245, 0x75283472, 0x31753b31, 0x3b31753b, 0x753b3175, + 0x31753b31, 0x0000003b, 0x00050005, 0x0000000d, 0x6f727265, 0x72675f72, 0x0070756f, 0x00060005, 0x0000000e, 0x6f727265, + 0x75735f72, 0x6f635f62, 0x00006564, 0x00040005, 0x0000000f, 0x61726170, 0x00305f6d, 0x00040005, 0x00000010, 0x61726170, + 0x00315f6d, 0x00040005, 0x00000011, 0x61726170, 0x00325f6d, 0x00040005, 0x00000012, 0x61726170, 0x00335f6d, 0x00090005, + 0x0000001a, 0x61757047, 0x676f4c76, 0x6f727245, 0x75283272, 0x31753b31, 0x3b31753b, 0x003b3175, 0x00050005, 0x00000016, + 0x6f727265, 0x72675f72, 0x0070756f, 0x00060005, 0x00000017, 0x6f727265, 0x75735f72, 0x6f635f62, 0x00006564, 0x00040005, + 0x00000018, 0x61726170, 0x00305f6d, 0x00040005, 0x00000019, 0x61726170, 0x00315f6d, 0x00070005, 0x0000001e, 0x6f736552, + 0x65637275, 0x65646e49, 0x66754278, 0x00726566, 0x00070006, 0x0000001e, 0x00000000, 0x6f736572, 0x65637275, 0x646e695f, + 0x00007865, 0x00030005, 0x00000020, 0x00000000, 0x00080005, 0x00000028, 0x45646d43, 0x726f7272, 0x756f4373, 0x7542746e, + 0x72656666, 0x00000000, 0x00080006, 0x00000028, 0x00000000, 0x5f646d63, 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, + 0x00030005, 0x0000002a, 0x00000000, 0x00050005, 0x0000003b, 0x6f727245, 0x66754272, 0x00726566, 0x00050006, 0x0000003b, + 0x00000000, 0x67616c66, 0x00000073, 0x00070006, 0x0000003b, 0x00000001, 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, + 0x00070006, 0x0000003b, 0x00000002, 0x6f727265, 0x625f7372, 0x65666675, 0x00000072, 0x00030005, 0x0000003d, 0x00000000, + 0x00070005, 0x00000056, 0x69746341, 0x6e496e6f, 0x42786564, 0x65666675, 0x00000072, 0x00070006, 0x00000056, 0x00000000, + 0x69746361, 0x695f6e6f, 0x7865646e, 0x00000000, 0x00030005, 0x00000058, 0x00000000, 0x00040005, 0x00000080, 0x61726170, + 0x0000006d, 0x00040005, 0x00000082, 0x61726170, 0x0000006d, 0x00040005, 0x00000084, 0x61726170, 0x0000006d, 0x00040005, + 0x00000086, 0x61726170, 0x0000006d, 0x00040005, 0x00000088, 0x61726170, 0x0000006d, 0x00040005, 0x00000089, 0x61726170, + 0x0000006d, 0x00060005, 0x0000008d, 0x69646e49, 0x74636572, 0x66667542, 0x00007265, 0x00070006, 0x0000008d, 0x00000000, + 0x69646e69, 0x74636572, 0x6675625f, 0x00726566, 0x00030005, 0x0000008f, 0x00000000, 0x00050005, 0x00000090, 0x66696e55, + 0x496d726f, 0x006f666e, 0x00050006, 0x00000090, 0x00000000, 0x696d696c, 0x00785f74, 0x00050006, 0x00000090, 0x00000001, + 0x696d696c, 0x00795f74, 0x00050006, 0x00000090, 0x00000002, 0x696d696c, 0x007a5f74, 0x00080006, 0x00000090, 0x00000003, + 0x69646e69, 0x74636572, 0x6f5f785f, 0x65736666, 0x00000074, 0x00030005, 0x00000092, 0x00000000, 0x00040005, 0x000000ad, + 0x61726170, 0x0000006d, 0x00040005, 0x000000ae, 0x61726170, 0x0000006d, 0x00040005, 0x000000af, 0x61726170, 0x0000006d, + 0x00040005, 0x000000b1, 0x61726170, 0x0000006d, 0x00040005, 0x000000ba, 0x61726170, 0x0000006d, 0x00040005, 0x000000bb, + 0x61726170, 0x0000006d, 0x00040005, 0x000000bc, 0x61726170, 0x0000006d, 0x00040005, 0x000000be, 0x61726170, 0x0000006d, + 0x00040005, 0x000000c8, 0x61726170, 0x0000006d, 0x00040005, 0x000000c9, 0x61726170, 0x0000006d, 0x00040005, 0x000000ca, + 0x61726170, 0x0000006d, 0x00040005, 0x000000cc, 0x61726170, 0x0000006d, 0x00040047, 0x0000001d, 0x00000006, 0x00000004, + 0x00030047, 0x0000001e, 0x00000003, 0x00040048, 0x0000001e, 0x00000000, 0x00000018, 0x00050048, 0x0000001e, 0x00000000, + 0x00000023, 0x00000000, 0x00040047, 0x00000020, 0x00000021, 0x00000002, 0x00040047, 0x00000020, 0x00000022, 0x00000000, + 0x00040047, 0x00000027, 0x00000006, 0x00000004, 0x00030047, 0x00000028, 0x00000003, 0x00050048, 0x00000028, 0x00000000, + 0x00000023, 0x00000000, 0x00040047, 0x0000002a, 0x00000021, 0x00000003, 0x00040047, 0x0000002a, 0x00000022, 0x00000000, + 0x00040047, 0x0000003a, 0x00000006, 0x00000004, 0x00030047, 0x0000003b, 0x00000003, 0x00050048, 0x0000003b, 0x00000000, + 0x00000023, 0x00000000, 0x00050048, 0x0000003b, 0x00000001, 0x00000023, 0x00000004, 0x00050048, 0x0000003b, 0x00000002, + 0x00000023, 0x00000008, 0x00040047, 0x0000003d, 0x00000021, 0x00000000, 0x00040047, 0x0000003d, 0x00000022, 0x00000000, + 0x00040047, 0x00000055, 0x00000006, 0x00000004, 0x00030047, 0x00000056, 0x00000003, 0x00040048, 0x00000056, 0x00000000, + 0x00000018, 0x00050048, 0x00000056, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000058, 0x00000021, 0x00000001, + 0x00040047, 0x00000058, 0x00000022, 0x00000000, 0x00040047, 0x0000008c, 0x00000006, 0x00000004, 0x00030047, 0x0000008d, + 0x00000003, 0x00050048, 0x0000008d, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x0000008f, 0x00000021, 0x00000000, + 0x00040047, 0x0000008f, 0x00000022, 0x00000001, 0x00030047, 0x00000090, 0x00000002, 0x00050048, 0x00000090, 0x00000000, + 0x00000023, 0x00000000, 0x00050048, 0x00000090, 0x00000001, 0x00000023, 0x00000004, 0x00050048, 0x00000090, 0x00000002, + 0x00000023, 0x00000008, 0x00050048, 0x00000090, 0x00000003, 0x00000023, 0x0000000c, 0x00020013, 0x00000002, 0x00030021, 0x00000003, 0x00000002, 0x00020014, 0x00000006, 0x00030021, 0x00000007, 0x00000006, 0x00040015, 0x0000000a, 0x00000020, - 0x00000000, 0x00040020, 0x0000000b, 0x00000007, 0x0000000a, 0x00070021, 0x0000000c, 0x00000002, 0x0000000b, 0x0000000b, - 0x0000000b, 0x0000000b, 0x0003001d, 0x00000014, 0x0000000a, 0x0003001e, 0x00000015, 0x00000014, 0x00040020, 0x00000016, - 0x00000002, 0x00000015, 0x0004003b, 0x00000016, 0x00000017, 0x00000002, 0x00040015, 0x00000018, 0x00000020, 0x00000001, - 0x0004002b, 0x00000018, 0x00000019, 0x00000000, 0x00040020, 0x0000001a, 0x00000002, 0x0000000a, 0x0003001d, 0x0000001e, - 0x0000000a, 0x0003001e, 0x0000001f, 0x0000001e, 0x00040020, 0x00000020, 0x00000002, 0x0000001f, 0x0004003b, 0x00000020, - 0x00000021, 0x00000002, 0x0004002b, 0x0000000a, 0x00000024, 0x00000001, 0x0004002b, 0x0000000a, 0x00000025, 0x00000000, - 0x0004002b, 0x0000000a, 0x00000028, 0x00000006, 0x0003001d, 0x00000031, 0x0000000a, 0x0005001e, 0x00000032, 0x0000000a, - 0x0000000a, 0x00000031, 0x00040020, 0x00000033, 0x00000002, 0x00000032, 0x0004003b, 0x00000033, 0x00000034, 0x00000002, - 0x0004002b, 0x00000018, 0x00000035, 0x00000001, 0x0004002b, 0x0000000a, 0x00000037, 0x00000010, 0x0004002b, 0x00000018, - 0x00000045, 0x00000002, 0x0004002b, 0x0000000a, 0x0000004a, 0x00000007, 0x0003001d, 0x0000004c, 0x0000000a, 0x0003001e, - 0x0000004d, 0x0000004c, 0x00040020, 0x0000004e, 0x00000002, 0x0000004d, 0x0004003b, 0x0000004e, 0x0000004f, 0x00000002, - 0x0004002b, 0x0000000a, 0x00000054, 0x00000008, 0x0004002b, 0x0000000a, 0x0000005a, 0x00000009, 0x0004002b, 0x0000000a, - 0x0000005f, 0x0000000a, 0x0004002b, 0x0000000a, 0x00000064, 0x0000000b, 0x0004002b, 0x0000000a, 0x00000069, 0x0000000c, - 0x0003001d, 0x0000006e, 0x0000000a, 0x0003001e, 0x0000006f, 0x0000006e, 0x00040020, 0x00000070, 0x00000002, 0x0000006f, - 0x0004003b, 0x00000070, 0x00000071, 0x00000002, 0x0006001e, 0x00000072, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, - 0x00040020, 0x00000073, 0x00000009, 0x00000072, 0x0004003b, 0x00000073, 0x00000074, 0x00000009, 0x0004002b, 0x00000018, - 0x00000075, 0x00000003, 0x00040020, 0x00000076, 0x00000009, 0x0000000a, 0x0004002b, 0x0000000a, 0x00000084, 0x00000002, - 0x0004002b, 0x0000000a, 0x0000008e, 0x00000005, 0x0004002b, 0x0000000a, 0x000000a9, 0x00000003, 0x00050036, 0x00000002, - 0x00000004, 0x00000000, 0x00000003, 0x000200f8, 0x00000005, 0x0004003b, 0x0000000b, 0x0000008f, 0x00000007, 0x0004003b, - 0x0000000b, 0x00000090, 0x00000007, 0x0004003b, 0x0000000b, 0x00000091, 0x00000007, 0x0004003b, 0x0000000b, 0x00000093, - 0x00000007, 0x0004003b, 0x0000000b, 0x0000009c, 0x00000007, 0x0004003b, 0x0000000b, 0x0000009d, 0x00000007, 0x0004003b, - 0x0000000b, 0x0000009e, 0x00000007, 0x0004003b, 0x0000000b, 0x000000a0, 0x00000007, 0x0004003b, 0x0000000b, 0x000000aa, - 0x00000007, 0x0004003b, 0x0000000b, 0x000000ab, 0x00000007, 0x0004003b, 0x0000000b, 0x000000ac, 0x00000007, 0x0004003b, - 0x0000000b, 0x000000ae, 0x00000007, 0x00050041, 0x00000076, 0x00000077, 0x00000074, 0x00000075, 0x0004003d, 0x0000000a, - 0x00000078, 0x00000077, 0x00060041, 0x0000001a, 0x00000079, 0x00000071, 0x00000019, 0x00000078, 0x0004003d, 0x0000000a, - 0x0000007a, 0x00000079, 0x00050041, 0x00000076, 0x0000007c, 0x00000074, 0x00000075, 0x0004003d, 0x0000000a, 0x0000007d, - 0x0000007c, 0x00050080, 0x0000000a, 0x0000007e, 0x0000007d, 0x00000024, 0x00060041, 0x0000001a, 0x0000007f, 0x00000071, - 0x00000019, 0x0000007e, 0x0004003d, 0x0000000a, 0x00000080, 0x0000007f, 0x00050041, 0x00000076, 0x00000082, 0x00000074, - 0x00000075, 0x0004003d, 0x0000000a, 0x00000083, 0x00000082, 0x00050080, 0x0000000a, 0x00000085, 0x00000083, 0x00000084, - 0x00060041, 0x0000001a, 0x00000086, 0x00000071, 0x00000019, 0x00000085, 0x0004003d, 0x0000000a, 0x00000087, 0x00000086, - 0x00050041, 0x00000076, 0x00000089, 0x00000074, 0x00000019, 0x0004003d, 0x0000000a, 0x0000008a, 0x00000089, 0x000500ac, - 0x00000006, 0x0000008b, 0x0000007a, 0x0000008a, 0x000300f7, 0x0000008d, 0x00000000, 0x000400fa, 0x0000008b, 0x0000008c, - 0x00000095, 0x000200f8, 0x0000008c, 0x0003003e, 0x0000008f, 0x0000008e, 0x0003003e, 0x00000090, 0x00000024, 0x0003003e, - 0x00000091, 0x0000007a, 0x0003003e, 0x00000093, 0x00000025, 0x00080039, 0x00000002, 0x00000094, 0x00000011, 0x0000008f, - 0x00000090, 0x00000091, 0x00000093, 0x000200f9, 0x0000008d, 0x000200f8, 0x00000095, 0x00050041, 0x00000076, 0x00000097, - 0x00000074, 0x00000035, 0x0004003d, 0x0000000a, 0x00000098, 0x00000097, 0x000500ac, 0x00000006, 0x00000099, 0x00000080, - 0x00000098, 0x000300f7, 0x0000009b, 0x00000000, 0x000400fa, 0x00000099, 0x0000009a, 0x000000a2, 0x000200f8, 0x0000009a, - 0x0003003e, 0x0000009c, 0x0000008e, 0x0003003e, 0x0000009d, 0x00000084, 0x0003003e, 0x0000009e, 0x00000080, 0x0003003e, - 0x000000a0, 0x00000025, 0x00080039, 0x00000002, 0x000000a1, 0x00000011, 0x0000009c, 0x0000009d, 0x0000009e, 0x000000a0, - 0x000200f9, 0x0000009b, 0x000200f8, 0x000000a2, 0x00050041, 0x00000076, 0x000000a4, 0x00000074, 0x00000045, 0x0004003d, - 0x0000000a, 0x000000a5, 0x000000a4, 0x000500ac, 0x00000006, 0x000000a6, 0x00000087, 0x000000a5, 0x000300f7, 0x000000a8, - 0x00000000, 0x000400fa, 0x000000a6, 0x000000a7, 0x000000a8, 0x000200f8, 0x000000a7, 0x0003003e, 0x000000aa, 0x0000008e, - 0x0003003e, 0x000000ab, 0x000000a9, 0x0003003e, 0x000000ac, 0x00000087, 0x0003003e, 0x000000ae, 0x00000025, 0x00080039, - 0x00000002, 0x000000af, 0x00000011, 0x000000aa, 0x000000ab, 0x000000ac, 0x000000ae, 0x000200f9, 0x000000a8, 0x000200f8, - 0x000000a8, 0x000200f9, 0x0000009b, 0x000200f8, 0x0000009b, 0x000200f9, 0x0000008d, 0x000200f8, 0x0000008d, 0x000100fd, - 0x00010038, 0x00050036, 0x00000006, 0x00000008, 0x00000000, 0x00000007, 0x000200f8, 0x00000009, 0x00060041, 0x0000001a, - 0x0000001b, 0x00000017, 0x00000019, 0x00000019, 0x0004003d, 0x0000000a, 0x0000001c, 0x0000001b, 0x00060041, 0x0000001a, - 0x00000023, 0x00000021, 0x00000019, 0x0000001c, 0x000700ea, 0x0000000a, 0x00000026, 0x00000023, 0x00000024, 0x00000025, - 0x00000024, 0x000500ae, 0x00000006, 0x00000029, 0x00000026, 0x00000028, 0x000200fe, 0x00000029, 0x00010038, 0x00050036, - 0x00000002, 0x00000011, 0x00000000, 0x0000000c, 0x00030037, 0x0000000b, 0x0000000d, 0x00030037, 0x0000000b, 0x0000000e, - 0x00030037, 0x0000000b, 0x0000000f, 0x00030037, 0x0000000b, 0x00000010, 0x000200f8, 0x00000012, 0x00040039, 0x00000006, - 0x0000002c, 0x00000008, 0x000300f7, 0x0000002e, 0x00000000, 0x000400fa, 0x0000002c, 0x0000002d, 0x0000002e, 0x000200f8, - 0x0000002d, 0x000100fd, 0x000200f8, 0x0000002e, 0x00050041, 0x0000001a, 0x00000036, 0x00000034, 0x00000035, 0x000700ea, - 0x0000000a, 0x00000038, 0x00000036, 0x00000024, 0x00000025, 0x00000037, 0x00050080, 0x0000000a, 0x0000003c, 0x00000038, - 0x00000037, 0x00050044, 0x0000000a, 0x0000003d, 0x00000034, 0x00000002, 0x0004007c, 0x00000018, 0x0000003e, 0x0000003d, - 0x0004007c, 0x0000000a, 0x0000003f, 0x0000003e, 0x000500ac, 0x00000006, 0x00000040, 0x0000003c, 0x0000003f, 0x000300f7, - 0x00000043, 0x00000000, 0x000400fa, 0x00000040, 0x00000042, 0x00000043, 0x000200f8, 0x00000042, 0x000100fd, 0x000200f8, - 0x00000043, 0x00060041, 0x0000001a, 0x00000048, 0x00000034, 0x00000045, 0x00000038, 0x0003003e, 0x00000048, 0x00000037, - 0x00050080, 0x0000000a, 0x0000004b, 0x00000038, 0x0000004a, 0x00060041, 0x0000001a, 0x00000050, 0x0000004f, 0x00000019, - 0x00000019, 0x0004003d, 0x0000000a, 0x00000051, 0x00000050, 0x00060041, 0x0000001a, 0x00000052, 0x00000034, 0x00000045, - 0x0000004b, 0x0003003e, 0x00000052, 0x00000051, 0x00050080, 0x0000000a, 0x00000055, 0x00000038, 0x00000054, 0x00060041, - 0x0000001a, 0x00000056, 0x00000017, 0x00000019, 0x00000019, 0x0004003d, 0x0000000a, 0x00000057, 0x00000056, 0x00060041, - 0x0000001a, 0x00000058, 0x00000034, 0x00000045, 0x00000055, 0x0003003e, 0x00000058, 0x00000057, 0x00050080, 0x0000000a, - 0x0000005b, 0x00000038, 0x0000005a, 0x0004003d, 0x0000000a, 0x0000005c, 0x0000000d, 0x00060041, 0x0000001a, 0x0000005d, - 0x00000034, 0x00000045, 0x0000005b, 0x0003003e, 0x0000005d, 0x0000005c, 0x00050080, 0x0000000a, 0x00000060, 0x00000038, - 0x0000005f, 0x0004003d, 0x0000000a, 0x00000061, 0x0000000e, 0x00060041, 0x0000001a, 0x00000062, 0x00000034, 0x00000045, - 0x00000060, 0x0003003e, 0x00000062, 0x00000061, 0x00050080, 0x0000000a, 0x00000065, 0x00000038, 0x00000064, 0x0004003d, - 0x0000000a, 0x00000066, 0x0000000f, 0x00060041, 0x0000001a, 0x00000067, 0x00000034, 0x00000045, 0x00000065, 0x0003003e, - 0x00000067, 0x00000066, 0x00050080, 0x0000000a, 0x0000006a, 0x00000038, 0x00000069, 0x0004003d, 0x0000000a, 0x0000006b, - 0x00000010, 0x00060041, 0x0000001a, 0x0000006c, 0x00000034, 0x00000045, 0x0000006a, 0x0003003e, 0x0000006c, 0x0000006b, - 0x000100fd, 0x00010038, + 0x00000000, 0x00040020, 0x0000000b, 0x00000007, 0x0000000a, 0x00090021, 0x0000000c, 0x00000002, 0x0000000b, 0x0000000b, + 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x00070021, 0x00000015, 0x00000002, 0x0000000b, 0x0000000b, 0x0000000b, + 0x0000000b, 0x0003001d, 0x0000001d, 0x0000000a, 0x0003001e, 0x0000001e, 0x0000001d, 0x00040020, 0x0000001f, 0x00000002, + 0x0000001e, 0x0004003b, 0x0000001f, 0x00000020, 0x00000002, 0x00040015, 0x00000021, 0x00000020, 0x00000001, 0x0004002b, + 0x00000021, 0x00000022, 0x00000000, 0x00040020, 0x00000023, 0x00000002, 0x0000000a, 0x0003001d, 0x00000027, 0x0000000a, + 0x0003001e, 0x00000028, 0x00000027, 0x00040020, 0x00000029, 0x00000002, 0x00000028, 0x0004003b, 0x00000029, 0x0000002a, + 0x00000002, 0x0004002b, 0x0000000a, 0x0000002d, 0x00000001, 0x0004002b, 0x0000000a, 0x0000002e, 0x00000000, 0x0004002b, + 0x0000000a, 0x00000031, 0x00000006, 0x0003001d, 0x0000003a, 0x0000000a, 0x0005001e, 0x0000003b, 0x0000000a, 0x0000000a, + 0x0000003a, 0x00040020, 0x0000003c, 0x00000002, 0x0000003b, 0x0004003b, 0x0000003c, 0x0000003d, 0x00000002, 0x0004002b, + 0x00000021, 0x0000003e, 0x00000001, 0x0004002b, 0x0000000a, 0x00000040, 0x00000010, 0x0004002b, 0x00000021, 0x0000004e, + 0x00000002, 0x0004002b, 0x0000000a, 0x00000053, 0x00000007, 0x0003001d, 0x00000055, 0x0000000a, 0x0003001e, 0x00000056, + 0x00000055, 0x00040020, 0x00000057, 0x00000002, 0x00000056, 0x0004003b, 0x00000057, 0x00000058, 0x00000002, 0x0004002b, + 0x0000000a, 0x0000005d, 0x00000008, 0x0004002b, 0x0000000a, 0x00000063, 0x00000009, 0x0004002b, 0x0000000a, 0x00000068, + 0x0000000a, 0x0004002b, 0x0000000a, 0x0000006d, 0x0000000b, 0x0004002b, 0x0000000a, 0x00000072, 0x0000000c, 0x0004002b, + 0x0000000a, 0x00000077, 0x0000000d, 0x0004002b, 0x0000000a, 0x0000007c, 0x0000000e, 0x0003001d, 0x0000008c, 0x0000000a, + 0x0003001e, 0x0000008d, 0x0000008c, 0x00040020, 0x0000008e, 0x00000002, 0x0000008d, 0x0004003b, 0x0000008e, 0x0000008f, + 0x00000002, 0x0006001e, 0x00000090, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x00040020, 0x00000091, 0x00000009, + 0x00000090, 0x0004003b, 0x00000091, 0x00000092, 0x00000009, 0x0004002b, 0x00000021, 0x00000093, 0x00000003, 0x00040020, + 0x00000094, 0x00000009, 0x0000000a, 0x0004002b, 0x0000000a, 0x000000a2, 0x00000002, 0x0004002b, 0x0000000a, 0x000000ac, + 0x00000005, 0x0004002b, 0x0000000a, 0x000000c7, 0x00000003, 0x00050036, 0x00000002, 0x00000004, 0x00000000, 0x00000003, + 0x000200f8, 0x00000005, 0x0004003b, 0x0000000b, 0x000000ad, 0x00000007, 0x0004003b, 0x0000000b, 0x000000ae, 0x00000007, + 0x0004003b, 0x0000000b, 0x000000af, 0x00000007, 0x0004003b, 0x0000000b, 0x000000b1, 0x00000007, 0x0004003b, 0x0000000b, + 0x000000ba, 0x00000007, 0x0004003b, 0x0000000b, 0x000000bb, 0x00000007, 0x0004003b, 0x0000000b, 0x000000bc, 0x00000007, + 0x0004003b, 0x0000000b, 0x000000be, 0x00000007, 0x0004003b, 0x0000000b, 0x000000c8, 0x00000007, 0x0004003b, 0x0000000b, + 0x000000c9, 0x00000007, 0x0004003b, 0x0000000b, 0x000000ca, 0x00000007, 0x0004003b, 0x0000000b, 0x000000cc, 0x00000007, + 0x00050041, 0x00000094, 0x00000095, 0x00000092, 0x00000093, 0x0004003d, 0x0000000a, 0x00000096, 0x00000095, 0x00060041, + 0x00000023, 0x00000097, 0x0000008f, 0x00000022, 0x00000096, 0x0004003d, 0x0000000a, 0x00000098, 0x00000097, 0x00050041, + 0x00000094, 0x0000009a, 0x00000092, 0x00000093, 0x0004003d, 0x0000000a, 0x0000009b, 0x0000009a, 0x00050080, 0x0000000a, + 0x0000009c, 0x0000009b, 0x0000002d, 0x00060041, 0x00000023, 0x0000009d, 0x0000008f, 0x00000022, 0x0000009c, 0x0004003d, + 0x0000000a, 0x0000009e, 0x0000009d, 0x00050041, 0x00000094, 0x000000a0, 0x00000092, 0x00000093, 0x0004003d, 0x0000000a, + 0x000000a1, 0x000000a0, 0x00050080, 0x0000000a, 0x000000a3, 0x000000a1, 0x000000a2, 0x00060041, 0x00000023, 0x000000a4, + 0x0000008f, 0x00000022, 0x000000a3, 0x0004003d, 0x0000000a, 0x000000a5, 0x000000a4, 0x00050041, 0x00000094, 0x000000a7, + 0x00000092, 0x00000022, 0x0004003d, 0x0000000a, 0x000000a8, 0x000000a7, 0x000500ac, 0x00000006, 0x000000a9, 0x00000098, + 0x000000a8, 0x000300f7, 0x000000ab, 0x00000000, 0x000400fa, 0x000000a9, 0x000000aa, 0x000000b3, 0x000200f8, 0x000000aa, + 0x0003003e, 0x000000ad, 0x000000ac, 0x0003003e, 0x000000ae, 0x0000002d, 0x0003003e, 0x000000af, 0x00000098, 0x0003003e, + 0x000000b1, 0x0000002e, 0x00080039, 0x00000002, 0x000000b2, 0x0000001a, 0x000000ad, 0x000000ae, 0x000000af, 0x000000b1, + 0x000200f9, 0x000000ab, 0x000200f8, 0x000000b3, 0x00050041, 0x00000094, 0x000000b5, 0x00000092, 0x0000003e, 0x0004003d, + 0x0000000a, 0x000000b6, 0x000000b5, 0x000500ac, 0x00000006, 0x000000b7, 0x0000009e, 0x000000b6, 0x000300f7, 0x000000b9, + 0x00000000, 0x000400fa, 0x000000b7, 0x000000b8, 0x000000c0, 0x000200f8, 0x000000b8, 0x0003003e, 0x000000ba, 0x000000ac, + 0x0003003e, 0x000000bb, 0x000000a2, 0x0003003e, 0x000000bc, 0x0000009e, 0x0003003e, 0x000000be, 0x0000002e, 0x00080039, + 0x00000002, 0x000000bf, 0x0000001a, 0x000000ba, 0x000000bb, 0x000000bc, 0x000000be, 0x000200f9, 0x000000b9, 0x000200f8, + 0x000000c0, 0x00050041, 0x00000094, 0x000000c2, 0x00000092, 0x0000004e, 0x0004003d, 0x0000000a, 0x000000c3, 0x000000c2, + 0x000500ac, 0x00000006, 0x000000c4, 0x000000a5, 0x000000c3, 0x000300f7, 0x000000c6, 0x00000000, 0x000400fa, 0x000000c4, + 0x000000c5, 0x000000c6, 0x000200f8, 0x000000c5, 0x0003003e, 0x000000c8, 0x000000ac, 0x0003003e, 0x000000c9, 0x000000c7, + 0x0003003e, 0x000000ca, 0x000000a5, 0x0003003e, 0x000000cc, 0x0000002e, 0x00080039, 0x00000002, 0x000000cd, 0x0000001a, + 0x000000c8, 0x000000c9, 0x000000ca, 0x000000cc, 0x000200f9, 0x000000c6, 0x000200f8, 0x000000c6, 0x000200f9, 0x000000b9, + 0x000200f8, 0x000000b9, 0x000200f9, 0x000000ab, 0x000200f8, 0x000000ab, 0x000100fd, 0x00010038, 0x00050036, 0x00000006, + 0x00000008, 0x00000000, 0x00000007, 0x000200f8, 0x00000009, 0x00060041, 0x00000023, 0x00000024, 0x00000020, 0x00000022, + 0x00000022, 0x0004003d, 0x0000000a, 0x00000025, 0x00000024, 0x00060041, 0x00000023, 0x0000002c, 0x0000002a, 0x00000022, + 0x00000025, 0x000700ea, 0x0000000a, 0x0000002f, 0x0000002c, 0x0000002d, 0x0000002e, 0x0000002d, 0x000500ae, 0x00000006, + 0x00000032, 0x0000002f, 0x00000031, 0x000200fe, 0x00000032, 0x00010038, 0x00050036, 0x00000002, 0x00000013, 0x00000000, + 0x0000000c, 0x00030037, 0x0000000b, 0x0000000d, 0x00030037, 0x0000000b, 0x0000000e, 0x00030037, 0x0000000b, 0x0000000f, + 0x00030037, 0x0000000b, 0x00000010, 0x00030037, 0x0000000b, 0x00000011, 0x00030037, 0x0000000b, 0x00000012, 0x000200f8, + 0x00000014, 0x00040039, 0x00000006, 0x00000035, 0x00000008, 0x000300f7, 0x00000037, 0x00000000, 0x000400fa, 0x00000035, + 0x00000036, 0x00000037, 0x000200f8, 0x00000036, 0x000100fd, 0x000200f8, 0x00000037, 0x00050041, 0x00000023, 0x0000003f, + 0x0000003d, 0x0000003e, 0x000700ea, 0x0000000a, 0x00000041, 0x0000003f, 0x0000002d, 0x0000002e, 0x00000040, 0x00050080, + 0x0000000a, 0x00000045, 0x00000041, 0x00000040, 0x00050044, 0x0000000a, 0x00000046, 0x0000003d, 0x00000002, 0x0004007c, + 0x00000021, 0x00000047, 0x00000046, 0x0004007c, 0x0000000a, 0x00000048, 0x00000047, 0x000500ac, 0x00000006, 0x00000049, + 0x00000045, 0x00000048, 0x000300f7, 0x0000004c, 0x00000000, 0x000400fa, 0x00000049, 0x0000004b, 0x0000004c, 0x000200f8, + 0x0000004b, 0x000100fd, 0x000200f8, 0x0000004c, 0x00060041, 0x00000023, 0x00000051, 0x0000003d, 0x0000004e, 0x00000041, + 0x0003003e, 0x00000051, 0x00000040, 0x00050080, 0x0000000a, 0x00000054, 0x00000041, 0x00000053, 0x00060041, 0x00000023, + 0x00000059, 0x00000058, 0x00000022, 0x00000022, 0x0004003d, 0x0000000a, 0x0000005a, 0x00000059, 0x00060041, 0x00000023, + 0x0000005b, 0x0000003d, 0x0000004e, 0x00000054, 0x0003003e, 0x0000005b, 0x0000005a, 0x00050080, 0x0000000a, 0x0000005e, + 0x00000041, 0x0000005d, 0x00060041, 0x00000023, 0x0000005f, 0x00000020, 0x00000022, 0x00000022, 0x0004003d, 0x0000000a, + 0x00000060, 0x0000005f, 0x00060041, 0x00000023, 0x00000061, 0x0000003d, 0x0000004e, 0x0000005e, 0x0003003e, 0x00000061, + 0x00000060, 0x00050080, 0x0000000a, 0x00000064, 0x00000041, 0x00000063, 0x0004003d, 0x0000000a, 0x00000065, 0x0000000d, + 0x00060041, 0x00000023, 0x00000066, 0x0000003d, 0x0000004e, 0x00000064, 0x0003003e, 0x00000066, 0x00000065, 0x00050080, + 0x0000000a, 0x00000069, 0x00000041, 0x00000068, 0x0004003d, 0x0000000a, 0x0000006a, 0x0000000e, 0x00060041, 0x00000023, + 0x0000006b, 0x0000003d, 0x0000004e, 0x00000069, 0x0003003e, 0x0000006b, 0x0000006a, 0x00050080, 0x0000000a, 0x0000006e, + 0x00000041, 0x0000006d, 0x0004003d, 0x0000000a, 0x0000006f, 0x0000000f, 0x00060041, 0x00000023, 0x00000070, 0x0000003d, + 0x0000004e, 0x0000006e, 0x0003003e, 0x00000070, 0x0000006f, 0x00050080, 0x0000000a, 0x00000073, 0x00000041, 0x00000072, + 0x0004003d, 0x0000000a, 0x00000074, 0x00000010, 0x00060041, 0x00000023, 0x00000075, 0x0000003d, 0x0000004e, 0x00000073, + 0x0003003e, 0x00000075, 0x00000074, 0x00050080, 0x0000000a, 0x00000078, 0x00000041, 0x00000077, 0x0004003d, 0x0000000a, + 0x00000079, 0x00000011, 0x00060041, 0x00000023, 0x0000007a, 0x0000003d, 0x0000004e, 0x00000078, 0x0003003e, 0x0000007a, + 0x00000079, 0x00050080, 0x0000000a, 0x0000007d, 0x00000041, 0x0000007c, 0x0004003d, 0x0000000a, 0x0000007e, 0x00000012, + 0x00060041, 0x00000023, 0x0000007f, 0x0000003d, 0x0000004e, 0x0000007d, 0x0003003e, 0x0000007f, 0x0000007e, 0x000100fd, + 0x00010038, 0x00050036, 0x00000002, 0x0000001a, 0x00000000, 0x00000015, 0x00030037, 0x0000000b, 0x00000016, 0x00030037, + 0x0000000b, 0x00000017, 0x00030037, 0x0000000b, 0x00000018, 0x00030037, 0x0000000b, 0x00000019, 0x000200f8, 0x0000001b, + 0x0004003b, 0x0000000b, 0x00000080, 0x00000007, 0x0004003b, 0x0000000b, 0x00000082, 0x00000007, 0x0004003b, 0x0000000b, + 0x00000084, 0x00000007, 0x0004003b, 0x0000000b, 0x00000086, 0x00000007, 0x0004003b, 0x0000000b, 0x00000088, 0x00000007, + 0x0004003b, 0x0000000b, 0x00000089, 0x00000007, 0x0004003d, 0x0000000a, 0x00000081, 0x00000016, 0x0003003e, 0x00000080, + 0x00000081, 0x0004003d, 0x0000000a, 0x00000083, 0x00000017, 0x0003003e, 0x00000082, 0x00000083, 0x0004003d, 0x0000000a, + 0x00000085, 0x00000018, 0x0003003e, 0x00000084, 0x00000085, 0x0004003d, 0x0000000a, 0x00000087, 0x00000019, 0x0003003e, + 0x00000086, 0x00000087, 0x0003003e, 0x00000088, 0x0000002e, 0x0003003e, 0x00000089, 0x0000002e, 0x000a0039, 0x00000002, + 0x0000008a, 0x00000013, 0x00000080, 0x00000082, 0x00000084, 0x00000086, 0x00000088, 0x00000089, 0x000100fd, 0x00010038, }; diff --git a/layers/vulkan/generated/cmd_validation_draw_indexed_indirect_index_buffer_vert.cpp b/layers/vulkan/generated/cmd_validation_draw_indexed_indirect_index_buffer_vert.cpp new file mode 100644 index 00000000000..2e06e88762e --- /dev/null +++ b/layers/vulkan/generated/cmd_validation_draw_indexed_indirect_index_buffer_vert.cpp @@ -0,0 +1,166 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See generate_spirv.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2021-2024 The Khronos Group Inc. + * Copyright (c) 2021-2024 Valve Corporation + * Copyright (c) 2021-2024 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************/ + +#include "cmd_validation_draw_indexed_indirect_index_buffer_vert.h" + +// To view SPIR-V, copy contents of array and paste in https://www.khronos.org/spir/visualizer/ +[[maybe_unused]] const uint32_t cmd_validation_draw_indexed_indirect_index_buffer_vert_size = 1363; +[[maybe_unused]] const uint32_t cmd_validation_draw_indexed_indirect_index_buffer_vert[1363] = { + 0x07230203, 0x00010000, 0x0008000b, 0x000000ca, 0x00000000, 0x00020011, 0x00000001, 0x0006000b, 0x00000001, 0x4c534c47, + 0x6474732e, 0x3035342e, 0x00000000, 0x0003000e, 0x00000000, 0x00000001, 0x0006000f, 0x00000000, 0x00000004, 0x6e69616d, + 0x00000000, 0x0000007e, 0x00030003, 0x00000002, 0x000001c2, 0x00070004, 0x415f4c47, 0x675f4252, 0x735f7570, 0x65646168, + 0x6e695f72, 0x00343674, 0x000a0004, 0x475f4c47, 0x4c474f4f, 0x70635f45, 0x74735f70, 0x5f656c79, 0x656e696c, 0x7269645f, + 0x69746365, 0x00006576, 0x00080004, 0x475f4c47, 0x4c474f4f, 0x6e695f45, 0x64756c63, 0x69645f65, 0x74636572, 0x00657669, + 0x00040005, 0x00000004, 0x6e69616d, 0x00000000, 0x00090005, 0x00000008, 0x4378614d, 0x7245646d, 0x73726f72, 0x6e756f43, + 0x61655274, 0x64656863, 0x00000028, 0x000b0005, 0x00000013, 0x61757047, 0x676f4c76, 0x6f727245, 0x75283472, 0x31753b31, + 0x3b31753b, 0x753b3175, 0x31753b31, 0x0000003b, 0x00050005, 0x0000000d, 0x6f727265, 0x72675f72, 0x0070756f, 0x00060005, + 0x0000000e, 0x6f727265, 0x75735f72, 0x6f635f62, 0x00006564, 0x00040005, 0x0000000f, 0x61726170, 0x00305f6d, 0x00040005, + 0x00000010, 0x61726170, 0x00315f6d, 0x00040005, 0x00000011, 0x61726170, 0x00325f6d, 0x00040005, 0x00000012, 0x61726170, + 0x00335f6d, 0x00070005, 0x00000017, 0x6f736552, 0x65637275, 0x65646e49, 0x66754278, 0x00726566, 0x00070006, 0x00000017, + 0x00000000, 0x6f736572, 0x65637275, 0x646e695f, 0x00007865, 0x00030005, 0x00000019, 0x00000000, 0x00080005, 0x00000021, + 0x45646d43, 0x726f7272, 0x756f4373, 0x7542746e, 0x72656666, 0x00000000, 0x00080006, 0x00000021, 0x00000000, 0x5f646d63, + 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, 0x00030005, 0x00000023, 0x00000000, 0x00050005, 0x00000034, 0x6f727245, + 0x66754272, 0x00726566, 0x00050006, 0x00000034, 0x00000000, 0x67616c66, 0x00000073, 0x00070006, 0x00000034, 0x00000001, + 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, 0x00070006, 0x00000034, 0x00000002, 0x6f727265, 0x625f7372, 0x65666675, + 0x00000072, 0x00030005, 0x00000036, 0x00000000, 0x00070005, 0x0000004f, 0x69746341, 0x6e496e6f, 0x42786564, 0x65666675, + 0x00000072, 0x00070006, 0x0000004f, 0x00000000, 0x69746361, 0x695f6e6f, 0x7865646e, 0x00000000, 0x00030005, 0x00000051, + 0x00000000, 0x00060005, 0x0000007c, 0x505f6c67, 0x65567265, 0x78657472, 0x00000000, 0x00060006, 0x0000007c, 0x00000000, + 0x505f6c67, 0x7469736f, 0x006e6f69, 0x00070006, 0x0000007c, 0x00000001, 0x505f6c67, 0x746e696f, 0x657a6953, 0x00000000, + 0x00070006, 0x0000007c, 0x00000002, 0x435f6c67, 0x4470696c, 0x61747369, 0x0065636e, 0x00070006, 0x0000007c, 0x00000003, + 0x435f6c67, 0x446c6c75, 0x61747369, 0x0065636e, 0x00030005, 0x0000007e, 0x00000000, 0x00050005, 0x00000082, 0x77617264, + 0x756f635f, 0x0000746e, 0x000c0005, 0x00000083, 0x77617244, 0x65646e49, 0x49646578, 0x7269646e, 0x49746365, 0x7865646e, + 0x66667542, 0x75507265, 0x61446873, 0x00006174, 0x00050006, 0x00000083, 0x00000000, 0x67616c66, 0x00000073, 0x00090006, + 0x00000083, 0x00000001, 0x77617264, 0x646d635f, 0x74735f73, 0x65646972, 0x6f77645f, 0x00736472, 0x000c0006, 0x00000083, + 0x00000002, 0x6e756f62, 0x6e695f64, 0x5f786564, 0x66667562, 0x695f7265, 0x6369646e, 0x635f7365, 0x746e756f, 0x00000000, + 0x00070006, 0x00000083, 0x00000003, 0x5f757063, 0x77617264, 0x756f635f, 0x0000746e, 0x00050005, 0x00000084, 0x66696e55, + 0x496d726f, 0x006f666e, 0x00040006, 0x00000084, 0x00000000, 0x00006370, 0x00030005, 0x00000086, 0x00000000, 0x00050005, + 0x00000092, 0x6e756f43, 0x66754274, 0x00726566, 0x00080006, 0x00000092, 0x00000000, 0x6e756f63, 0x72665f74, 0x625f6d6f, + 0x65666675, 0x00000072, 0x00030005, 0x00000094, 0x00000000, 0x00040005, 0x00000097, 0x77617264, 0x0000695f, 0x00050005, + 0x000000a2, 0x77617244, 0x66667542, 0x00007265, 0x000a0006, 0x000000a2, 0x00000000, 0x77617264, 0x646e695f, 0x64657865, + 0x646e695f, 0x63657269, 0x6d635f74, 0x00007364, 0x00030005, 0x000000a4, 0x00000000, 0x00040005, 0x000000be, 0x61726170, + 0x0000006d, 0x00040005, 0x000000bf, 0x61726170, 0x0000006d, 0x00040005, 0x000000c0, 0x61726170, 0x0000006d, 0x00040005, + 0x000000c2, 0x61726170, 0x0000006d, 0x00040005, 0x000000c4, 0x61726170, 0x0000006d, 0x00040005, 0x000000c6, 0x61726170, + 0x0000006d, 0x00040047, 0x00000016, 0x00000006, 0x00000004, 0x00030047, 0x00000017, 0x00000003, 0x00040048, 0x00000017, + 0x00000000, 0x00000018, 0x00050048, 0x00000017, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000019, 0x00000021, + 0x00000002, 0x00040047, 0x00000019, 0x00000022, 0x00000000, 0x00040047, 0x00000020, 0x00000006, 0x00000004, 0x00030047, + 0x00000021, 0x00000003, 0x00050048, 0x00000021, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000023, 0x00000021, + 0x00000003, 0x00040047, 0x00000023, 0x00000022, 0x00000000, 0x00040047, 0x00000033, 0x00000006, 0x00000004, 0x00030047, + 0x00000034, 0x00000003, 0x00050048, 0x00000034, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x00000034, 0x00000001, + 0x00000023, 0x00000004, 0x00050048, 0x00000034, 0x00000002, 0x00000023, 0x00000008, 0x00040047, 0x00000036, 0x00000021, + 0x00000000, 0x00040047, 0x00000036, 0x00000022, 0x00000000, 0x00040047, 0x0000004e, 0x00000006, 0x00000004, 0x00030047, + 0x0000004f, 0x00000003, 0x00040048, 0x0000004f, 0x00000000, 0x00000018, 0x00050048, 0x0000004f, 0x00000000, 0x00000023, + 0x00000000, 0x00040047, 0x00000051, 0x00000021, 0x00000001, 0x00040047, 0x00000051, 0x00000022, 0x00000000, 0x00030047, + 0x0000007c, 0x00000002, 0x00050048, 0x0000007c, 0x00000000, 0x0000000b, 0x00000000, 0x00050048, 0x0000007c, 0x00000001, + 0x0000000b, 0x00000001, 0x00050048, 0x0000007c, 0x00000002, 0x0000000b, 0x00000003, 0x00050048, 0x0000007c, 0x00000003, + 0x0000000b, 0x00000004, 0x00050048, 0x00000083, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x00000083, 0x00000001, + 0x00000023, 0x00000004, 0x00050048, 0x00000083, 0x00000002, 0x00000023, 0x00000008, 0x00050048, 0x00000083, 0x00000003, + 0x00000023, 0x0000000c, 0x00030047, 0x00000084, 0x00000002, 0x00050048, 0x00000084, 0x00000000, 0x00000023, 0x00000000, + 0x00030047, 0x00000092, 0x00000003, 0x00040048, 0x00000092, 0x00000000, 0x00000018, 0x00050048, 0x00000092, 0x00000000, + 0x00000023, 0x00000000, 0x00040047, 0x00000094, 0x00000021, 0x00000001, 0x00040047, 0x00000094, 0x00000022, 0x00000001, + 0x00040047, 0x000000a1, 0x00000006, 0x00000004, 0x00030047, 0x000000a2, 0x00000003, 0x00040048, 0x000000a2, 0x00000000, + 0x00000018, 0x00050048, 0x000000a2, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x000000a4, 0x00000021, 0x00000000, + 0x00040047, 0x000000a4, 0x00000022, 0x00000001, 0x00020013, 0x00000002, 0x00030021, 0x00000003, 0x00000002, 0x00020014, + 0x00000006, 0x00030021, 0x00000007, 0x00000006, 0x00040015, 0x0000000a, 0x00000020, 0x00000000, 0x00040020, 0x0000000b, + 0x00000007, 0x0000000a, 0x00090021, 0x0000000c, 0x00000002, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, + 0x0000000b, 0x0003001d, 0x00000016, 0x0000000a, 0x0003001e, 0x00000017, 0x00000016, 0x00040020, 0x00000018, 0x00000002, + 0x00000017, 0x0004003b, 0x00000018, 0x00000019, 0x00000002, 0x00040015, 0x0000001a, 0x00000020, 0x00000001, 0x0004002b, + 0x0000001a, 0x0000001b, 0x00000000, 0x00040020, 0x0000001c, 0x00000002, 0x0000000a, 0x0003001d, 0x00000020, 0x0000000a, + 0x0003001e, 0x00000021, 0x00000020, 0x00040020, 0x00000022, 0x00000002, 0x00000021, 0x0004003b, 0x00000022, 0x00000023, + 0x00000002, 0x0004002b, 0x0000000a, 0x00000026, 0x00000001, 0x0004002b, 0x0000000a, 0x00000027, 0x00000000, 0x0004002b, + 0x0000000a, 0x0000002a, 0x00000006, 0x0003001d, 0x00000033, 0x0000000a, 0x0005001e, 0x00000034, 0x0000000a, 0x0000000a, + 0x00000033, 0x00040020, 0x00000035, 0x00000002, 0x00000034, 0x0004003b, 0x00000035, 0x00000036, 0x00000002, 0x0004002b, + 0x0000001a, 0x00000037, 0x00000001, 0x0004002b, 0x0000000a, 0x00000039, 0x00000010, 0x0004002b, 0x0000001a, 0x00000047, + 0x00000002, 0x0004002b, 0x0000000a, 0x0000004c, 0x00000007, 0x0003001d, 0x0000004e, 0x0000000a, 0x0003001e, 0x0000004f, + 0x0000004e, 0x00040020, 0x00000050, 0x00000002, 0x0000004f, 0x0004003b, 0x00000050, 0x00000051, 0x00000002, 0x0004002b, + 0x0000000a, 0x00000056, 0x00000008, 0x0004002b, 0x0000000a, 0x0000005c, 0x00000009, 0x0004002b, 0x0000000a, 0x00000061, + 0x0000000a, 0x0004002b, 0x0000000a, 0x00000066, 0x0000000b, 0x0004002b, 0x0000000a, 0x0000006b, 0x0000000c, 0x0004002b, + 0x0000000a, 0x00000070, 0x0000000d, 0x0004002b, 0x0000000a, 0x00000075, 0x0000000e, 0x00030016, 0x00000079, 0x00000020, + 0x00040017, 0x0000007a, 0x00000079, 0x00000004, 0x0004001c, 0x0000007b, 0x00000079, 0x00000026, 0x0006001e, 0x0000007c, + 0x0000007a, 0x00000079, 0x0000007b, 0x0000007b, 0x00040020, 0x0000007d, 0x00000003, 0x0000007c, 0x0004003b, 0x0000007d, + 0x0000007e, 0x00000003, 0x0004002b, 0x00000079, 0x0000007f, 0x3f800000, 0x00040020, 0x00000080, 0x00000003, 0x00000079, + 0x0006001e, 0x00000083, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x0003001e, 0x00000084, 0x00000083, 0x00040020, + 0x00000085, 0x00000009, 0x00000084, 0x0004003b, 0x00000085, 0x00000086, 0x00000009, 0x00040020, 0x00000087, 0x00000009, + 0x0000000a, 0x0004002b, 0x0000001a, 0x0000008e, 0x00000003, 0x0003001e, 0x00000092, 0x0000000a, 0x00040020, 0x00000093, + 0x00000002, 0x00000092, 0x0004003b, 0x00000093, 0x00000094, 0x00000002, 0x0003001d, 0x000000a1, 0x0000000a, 0x0003001e, + 0x000000a2, 0x000000a1, 0x00040020, 0x000000a3, 0x00000002, 0x000000a2, 0x0004003b, 0x000000a3, 0x000000a4, 0x00000002, + 0x0004002b, 0x0000000a, 0x000000b1, 0x00000002, 0x0004002b, 0x0000000a, 0x000000bd, 0x00000004, 0x00050036, 0x00000002, + 0x00000004, 0x00000000, 0x00000003, 0x000200f8, 0x00000005, 0x0004003b, 0x0000000b, 0x00000082, 0x00000007, 0x0004003b, + 0x0000000b, 0x00000097, 0x00000007, 0x0004003b, 0x0000000b, 0x000000be, 0x00000007, 0x0004003b, 0x0000000b, 0x000000bf, + 0x00000007, 0x0004003b, 0x0000000b, 0x000000c0, 0x00000007, 0x0004003b, 0x0000000b, 0x000000c2, 0x00000007, 0x0004003b, + 0x0000000b, 0x000000c4, 0x00000007, 0x0004003b, 0x0000000b, 0x000000c6, 0x00000007, 0x00050041, 0x00000080, 0x00000081, + 0x0000007e, 0x00000037, 0x0003003e, 0x00000081, 0x0000007f, 0x0003003e, 0x00000082, 0x00000027, 0x00060041, 0x00000087, + 0x00000088, 0x00000086, 0x0000001b, 0x0000001b, 0x0004003d, 0x0000000a, 0x00000089, 0x00000088, 0x000500c7, 0x0000000a, + 0x0000008a, 0x00000089, 0x00000026, 0x000500aa, 0x00000006, 0x0000008b, 0x0000008a, 0x00000027, 0x000300f7, 0x0000008d, + 0x00000000, 0x000400fa, 0x0000008b, 0x0000008c, 0x00000091, 0x000200f8, 0x0000008c, 0x00060041, 0x00000087, 0x0000008f, + 0x00000086, 0x0000001b, 0x0000008e, 0x0004003d, 0x0000000a, 0x00000090, 0x0000008f, 0x0003003e, 0x00000082, 0x00000090, + 0x000200f9, 0x0000008d, 0x000200f8, 0x00000091, 0x00050041, 0x0000001c, 0x00000095, 0x00000094, 0x0000001b, 0x0004003d, + 0x0000000a, 0x00000096, 0x00000095, 0x0003003e, 0x00000082, 0x00000096, 0x000200f9, 0x0000008d, 0x000200f8, 0x0000008d, + 0x0003003e, 0x00000097, 0x00000027, 0x000200f9, 0x00000098, 0x000200f8, 0x00000098, 0x000400f6, 0x0000009a, 0x0000009b, + 0x00000000, 0x000200f9, 0x0000009c, 0x000200f8, 0x0000009c, 0x0004003d, 0x0000000a, 0x0000009d, 0x00000097, 0x0004003d, + 0x0000000a, 0x0000009e, 0x00000082, 0x000500b0, 0x00000006, 0x0000009f, 0x0000009d, 0x0000009e, 0x000400fa, 0x0000009f, + 0x00000099, 0x0000009a, 0x000200f8, 0x00000099, 0x0004003d, 0x0000000a, 0x000000a5, 0x00000097, 0x00060041, 0x00000087, + 0x000000a6, 0x00000086, 0x0000001b, 0x00000037, 0x0004003d, 0x0000000a, 0x000000a7, 0x000000a6, 0x00050084, 0x0000000a, + 0x000000a8, 0x000000a5, 0x000000a7, 0x00060041, 0x0000001c, 0x000000aa, 0x000000a4, 0x0000001b, 0x000000a8, 0x0004003d, + 0x0000000a, 0x000000ab, 0x000000aa, 0x00060041, 0x00000087, 0x000000ae, 0x00000086, 0x0000001b, 0x00000037, 0x0004003d, + 0x0000000a, 0x000000af, 0x000000ae, 0x00050084, 0x0000000a, 0x000000b0, 0x000000a5, 0x000000af, 0x00050080, 0x0000000a, + 0x000000b2, 0x000000b0, 0x000000b1, 0x00060041, 0x0000001c, 0x000000b3, 0x000000a4, 0x0000001b, 0x000000b2, 0x0004003d, + 0x0000000a, 0x000000b4, 0x000000b3, 0x00050080, 0x0000000a, 0x000000b7, 0x000000b4, 0x000000ab, 0x00060041, 0x00000087, + 0x000000b8, 0x00000086, 0x0000001b, 0x00000047, 0x0004003d, 0x0000000a, 0x000000b9, 0x000000b8, 0x000500ac, 0x00000006, + 0x000000ba, 0x000000b7, 0x000000b9, 0x000300f7, 0x000000bc, 0x00000000, 0x000400fa, 0x000000ba, 0x000000bb, 0x000000bc, + 0x000200f8, 0x000000bb, 0x0003003e, 0x000000be, 0x000000bd, 0x0003003e, 0x000000bf, 0x00000056, 0x0004003d, 0x0000000a, + 0x000000c1, 0x00000097, 0x0003003e, 0x000000c0, 0x000000c1, 0x0003003e, 0x000000c2, 0x000000b4, 0x0003003e, 0x000000c4, + 0x000000ab, 0x0003003e, 0x000000c6, 0x00000027, 0x000a0039, 0x00000002, 0x000000c7, 0x00000013, 0x000000be, 0x000000bf, + 0x000000c0, 0x000000c2, 0x000000c4, 0x000000c6, 0x000200f9, 0x000000bc, 0x000200f8, 0x000000bc, 0x000200f9, 0x0000009b, + 0x000200f8, 0x0000009b, 0x0004003d, 0x0000000a, 0x000000c8, 0x00000097, 0x00050080, 0x0000000a, 0x000000c9, 0x000000c8, + 0x00000037, 0x0003003e, 0x00000097, 0x000000c9, 0x000200f9, 0x00000098, 0x000200f8, 0x0000009a, 0x000100fd, 0x00010038, + 0x00050036, 0x00000006, 0x00000008, 0x00000000, 0x00000007, 0x000200f8, 0x00000009, 0x00060041, 0x0000001c, 0x0000001d, + 0x00000019, 0x0000001b, 0x0000001b, 0x0004003d, 0x0000000a, 0x0000001e, 0x0000001d, 0x00060041, 0x0000001c, 0x00000025, + 0x00000023, 0x0000001b, 0x0000001e, 0x000700ea, 0x0000000a, 0x00000028, 0x00000025, 0x00000026, 0x00000027, 0x00000026, + 0x000500ae, 0x00000006, 0x0000002b, 0x00000028, 0x0000002a, 0x000200fe, 0x0000002b, 0x00010038, 0x00050036, 0x00000002, + 0x00000013, 0x00000000, 0x0000000c, 0x00030037, 0x0000000b, 0x0000000d, 0x00030037, 0x0000000b, 0x0000000e, 0x00030037, + 0x0000000b, 0x0000000f, 0x00030037, 0x0000000b, 0x00000010, 0x00030037, 0x0000000b, 0x00000011, 0x00030037, 0x0000000b, + 0x00000012, 0x000200f8, 0x00000014, 0x00040039, 0x00000006, 0x0000002e, 0x00000008, 0x000300f7, 0x00000030, 0x00000000, + 0x000400fa, 0x0000002e, 0x0000002f, 0x00000030, 0x000200f8, 0x0000002f, 0x000100fd, 0x000200f8, 0x00000030, 0x00050041, + 0x0000001c, 0x00000038, 0x00000036, 0x00000037, 0x000700ea, 0x0000000a, 0x0000003a, 0x00000038, 0x00000026, 0x00000027, + 0x00000039, 0x00050080, 0x0000000a, 0x0000003e, 0x0000003a, 0x00000039, 0x00050044, 0x0000000a, 0x0000003f, 0x00000036, + 0x00000002, 0x0004007c, 0x0000001a, 0x00000040, 0x0000003f, 0x0004007c, 0x0000000a, 0x00000041, 0x00000040, 0x000500ac, + 0x00000006, 0x00000042, 0x0000003e, 0x00000041, 0x000300f7, 0x00000045, 0x00000000, 0x000400fa, 0x00000042, 0x00000044, + 0x00000045, 0x000200f8, 0x00000044, 0x000100fd, 0x000200f8, 0x00000045, 0x00060041, 0x0000001c, 0x0000004a, 0x00000036, + 0x00000047, 0x0000003a, 0x0003003e, 0x0000004a, 0x00000039, 0x00050080, 0x0000000a, 0x0000004d, 0x0000003a, 0x0000004c, + 0x00060041, 0x0000001c, 0x00000052, 0x00000051, 0x0000001b, 0x0000001b, 0x0004003d, 0x0000000a, 0x00000053, 0x00000052, + 0x00060041, 0x0000001c, 0x00000054, 0x00000036, 0x00000047, 0x0000004d, 0x0003003e, 0x00000054, 0x00000053, 0x00050080, + 0x0000000a, 0x00000057, 0x0000003a, 0x00000056, 0x00060041, 0x0000001c, 0x00000058, 0x00000019, 0x0000001b, 0x0000001b, + 0x0004003d, 0x0000000a, 0x00000059, 0x00000058, 0x00060041, 0x0000001c, 0x0000005a, 0x00000036, 0x00000047, 0x00000057, + 0x0003003e, 0x0000005a, 0x00000059, 0x00050080, 0x0000000a, 0x0000005d, 0x0000003a, 0x0000005c, 0x0004003d, 0x0000000a, + 0x0000005e, 0x0000000d, 0x00060041, 0x0000001c, 0x0000005f, 0x00000036, 0x00000047, 0x0000005d, 0x0003003e, 0x0000005f, + 0x0000005e, 0x00050080, 0x0000000a, 0x00000062, 0x0000003a, 0x00000061, 0x0004003d, 0x0000000a, 0x00000063, 0x0000000e, + 0x00060041, 0x0000001c, 0x00000064, 0x00000036, 0x00000047, 0x00000062, 0x0003003e, 0x00000064, 0x00000063, 0x00050080, + 0x0000000a, 0x00000067, 0x0000003a, 0x00000066, 0x0004003d, 0x0000000a, 0x00000068, 0x0000000f, 0x00060041, 0x0000001c, + 0x00000069, 0x00000036, 0x00000047, 0x00000067, 0x0003003e, 0x00000069, 0x00000068, 0x00050080, 0x0000000a, 0x0000006c, + 0x0000003a, 0x0000006b, 0x0004003d, 0x0000000a, 0x0000006d, 0x00000010, 0x00060041, 0x0000001c, 0x0000006e, 0x00000036, + 0x00000047, 0x0000006c, 0x0003003e, 0x0000006e, 0x0000006d, 0x00050080, 0x0000000a, 0x00000071, 0x0000003a, 0x00000070, + 0x0004003d, 0x0000000a, 0x00000072, 0x00000011, 0x00060041, 0x0000001c, 0x00000073, 0x00000036, 0x00000047, 0x00000071, + 0x0003003e, 0x00000073, 0x00000072, 0x00050080, 0x0000000a, 0x00000076, 0x0000003a, 0x00000075, 0x0004003d, 0x0000000a, + 0x00000077, 0x00000012, 0x00060041, 0x0000001c, 0x00000078, 0x00000036, 0x00000047, 0x00000076, 0x0003003e, 0x00000078, + 0x00000077, 0x000100fd, 0x00010038, +}; diff --git a/layers/vulkan/generated/cmd_validation_draw_indexed_indirect_index_buffer_vert.h b/layers/vulkan/generated/cmd_validation_draw_indexed_indirect_index_buffer_vert.h new file mode 100644 index 00000000000..b79699a4cc3 --- /dev/null +++ b/layers/vulkan/generated/cmd_validation_draw_indexed_indirect_index_buffer_vert.h @@ -0,0 +1,30 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See generate_spirv.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2021-2024 The Khronos Group Inc. + * Copyright (c) 2021-2024 Valve Corporation + * Copyright (c) 2021-2024 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************/ + +#pragma once + +#include + +// To view SPIR-V, copy contents of array and paste in https://www.khronos.org/spir/visualizer/ +extern const uint32_t cmd_validation_draw_indexed_indirect_index_buffer_vert_size; +extern const uint32_t cmd_validation_draw_indexed_indirect_index_buffer_vert[]; diff --git a/layers/vulkan/generated/cmd_validation_draw_indexed_indirect_vertex_buffer_vert.cpp b/layers/vulkan/generated/cmd_validation_draw_indexed_indirect_vertex_buffer_vert.cpp new file mode 100644 index 00000000000..36e72a07b3c --- /dev/null +++ b/layers/vulkan/generated/cmd_validation_draw_indexed_indirect_vertex_buffer_vert.cpp @@ -0,0 +1,229 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See generate_spirv.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2021-2024 The Khronos Group Inc. + * Copyright (c) 2021-2024 Valve Corporation + * Copyright (c) 2021-2024 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************/ + +#include "cmd_validation_draw_indexed_indirect_vertex_buffer_vert.h" + +// To view SPIR-V, copy contents of array and paste in https://www.khronos.org/spir/visualizer/ +[[maybe_unused]] const uint32_t cmd_validation_draw_indexed_indirect_vertex_buffer_vert_size = 1999; +[[maybe_unused]] const uint32_t cmd_validation_draw_indexed_indirect_vertex_buffer_vert[1999] = { + 0x07230203, 0x00010000, 0x0008000b, 0x00000148, 0x00000000, 0x00020011, 0x00000001, 0x0006000b, 0x00000001, 0x4c534c47, + 0x6474732e, 0x3035342e, 0x00000000, 0x0003000e, 0x00000000, 0x00000001, 0x0007000f, 0x00000000, 0x00000004, 0x6e69616d, + 0x00000000, 0x000000e7, 0x000000fd, 0x00030003, 0x00000002, 0x000001c2, 0x00070004, 0x415f4c47, 0x675f4252, 0x735f7570, + 0x65646168, 0x6e695f72, 0x00343674, 0x000a0004, 0x475f4c47, 0x4c474f4f, 0x70635f45, 0x74735f70, 0x5f656c79, 0x656e696c, + 0x7269645f, 0x69746365, 0x00006576, 0x00080004, 0x475f4c47, 0x4c474f4f, 0x6e695f45, 0x64756c63, 0x69645f65, 0x74636572, + 0x00657669, 0x00040005, 0x00000004, 0x6e69616d, 0x00000000, 0x00090005, 0x00000008, 0x4378614d, 0x7245646d, 0x73726f72, + 0x6e756f43, 0x61655274, 0x64656863, 0x00000028, 0x000b0005, 0x00000013, 0x61757047, 0x676f4c76, 0x6f727245, 0x75283472, + 0x31753b31, 0x3b31753b, 0x753b3175, 0x31753b31, 0x0000003b, 0x00050005, 0x0000000d, 0x6f727265, 0x72675f72, 0x0070756f, + 0x00060005, 0x0000000e, 0x6f727265, 0x75735f72, 0x6f635f62, 0x00006564, 0x00040005, 0x0000000f, 0x61726170, 0x00305f6d, + 0x00040005, 0x00000010, 0x61726170, 0x00315f6d, 0x00040005, 0x00000011, 0x61726170, 0x00325f6d, 0x00040005, 0x00000012, + 0x61726170, 0x00335f6d, 0x00080005, 0x00000017, 0x5f746567, 0x74726576, 0x695f7865, 0x7865646e, 0x3b317528, 0x00000000, + 0x00030005, 0x00000016, 0x00000069, 0x000b0005, 0x00000020, 0x696c6156, 0x65746164, 0x74726556, 0x6e497865, 0x28786564, + 0x753b3175, 0x31693b31, 0x3b31753b, 0x00000000, 0x00040005, 0x0000001c, 0x77617264, 0x0000695f, 0x00070005, 0x0000001d, + 0x65646e69, 0x75625f78, 0x72656666, 0x66666f5f, 0x00746573, 0x00060005, 0x0000001e, 0x74726576, 0x6f5f7865, 0x65736666, + 0x00000074, 0x000b0005, 0x0000001f, 0x6c616d73, 0x7473656c, 0x7265765f, 0x5f786574, 0x72747461, 0x74756269, 0x635f7365, + 0x746e756f, 0x00000000, 0x00070005, 0x00000024, 0x6f736552, 0x65637275, 0x65646e49, 0x66754278, 0x00726566, 0x00070006, + 0x00000024, 0x00000000, 0x6f736572, 0x65637275, 0x646e695f, 0x00007865, 0x00030005, 0x00000026, 0x00000000, 0x00080005, + 0x0000002d, 0x45646d43, 0x726f7272, 0x756f4373, 0x7542746e, 0x72656666, 0x00000000, 0x00080006, 0x0000002d, 0x00000000, + 0x5f646d63, 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, 0x00030005, 0x0000002f, 0x00000000, 0x00050005, 0x00000040, + 0x6f727245, 0x66754272, 0x00726566, 0x00050006, 0x00000040, 0x00000000, 0x67616c66, 0x00000073, 0x00070006, 0x00000040, + 0x00000001, 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, 0x00070006, 0x00000040, 0x00000002, 0x6f727265, 0x625f7372, + 0x65666675, 0x00000072, 0x00030005, 0x00000042, 0x00000000, 0x00070005, 0x0000005b, 0x69746341, 0x6e496e6f, 0x42786564, + 0x65666675, 0x00000072, 0x00070006, 0x0000005b, 0x00000000, 0x69746361, 0x695f6e6f, 0x7865646e, 0x00000000, 0x00030005, + 0x0000005d, 0x00000000, 0x000c0005, 0x00000085, 0x77617244, 0x65646e49, 0x49646578, 0x7269646e, 0x56746365, 0x65747265, + 0x66754278, 0x50726566, 0x44687375, 0x00617461, 0x00050006, 0x00000085, 0x00000000, 0x67616c66, 0x00000073, 0x00060006, + 0x00000085, 0x00000001, 0x65646e69, 0x69775f78, 0x00687464, 0x00090006, 0x00000085, 0x00000002, 0x77617264, 0x646d635f, + 0x74735f73, 0x65646972, 0x6f77645f, 0x00736472, 0x000c0006, 0x00000085, 0x00000003, 0x6e756f62, 0x6e695f64, 0x5f786564, + 0x66667562, 0x695f7265, 0x6369646e, 0x635f7365, 0x746e756f, 0x00000000, 0x00070006, 0x00000085, 0x00000004, 0x5f757063, + 0x77617264, 0x756f635f, 0x0000746e, 0x000c0006, 0x00000085, 0x00000005, 0x6c616d73, 0x7473656c, 0x7265765f, 0x5f786574, + 0x72747461, 0x74756269, 0x635f7365, 0x746e756f, 0x00000000, 0x00050005, 0x00000086, 0x66696e55, 0x496d726f, 0x006f666e, + 0x00040006, 0x00000086, 0x00000000, 0x00006370, 0x00030005, 0x00000088, 0x00000000, 0x00060005, 0x00000091, 0x65646e49, + 0x66754278, 0x33726566, 0x00000032, 0x00070006, 0x00000091, 0x00000000, 0x65646e69, 0x75625f78, 0x72656666, 0x00000000, + 0x00030005, 0x00000093, 0x00000000, 0x00040005, 0x000000cb, 0x61726170, 0x0000006d, 0x00040005, 0x000000d8, 0x61726170, + 0x0000006d, 0x00040005, 0x000000d9, 0x61726170, 0x0000006d, 0x00040005, 0x000000da, 0x61726170, 0x0000006d, 0x00040005, + 0x000000dc, 0x61726170, 0x0000006d, 0x00040005, 0x000000de, 0x61726170, 0x0000006d, 0x00040005, 0x000000df, 0x61726170, + 0x0000006d, 0x00060005, 0x000000e5, 0x505f6c67, 0x65567265, 0x78657472, 0x00000000, 0x00060006, 0x000000e5, 0x00000000, + 0x505f6c67, 0x7469736f, 0x006e6f69, 0x00070006, 0x000000e5, 0x00000001, 0x505f6c67, 0x746e696f, 0x657a6953, 0x00000000, + 0x00070006, 0x000000e5, 0x00000002, 0x435f6c67, 0x4470696c, 0x61747369, 0x0065636e, 0x00070006, 0x000000e5, 0x00000003, + 0x435f6c67, 0x446c6c75, 0x61747369, 0x0065636e, 0x00030005, 0x000000e7, 0x00000000, 0x00050005, 0x000000eb, 0x77617264, + 0x756f635f, 0x0000746e, 0x00050005, 0x000000f6, 0x6e756f43, 0x66754274, 0x00726566, 0x00080006, 0x000000f6, 0x00000000, + 0x6e756f63, 0x72665f74, 0x625f6d6f, 0x65666675, 0x00000072, 0x00030005, 0x000000f8, 0x00000000, 0x00060005, 0x000000fd, + 0x565f6c67, 0x65747265, 0x646e4978, 0x00007865, 0x00040005, 0x00000100, 0x77617264, 0x0000695f, 0x00050005, 0x0000010b, + 0x77617244, 0x66667542, 0x00007265, 0x000a0006, 0x0000010b, 0x00000000, 0x77617264, 0x646e695f, 0x64657865, 0x646e695f, + 0x63657269, 0x6d635f74, 0x00007364, 0x00030005, 0x0000010d, 0x00000000, 0x00040005, 0x0000013c, 0x61726170, 0x0000006d, + 0x00040005, 0x0000013e, 0x61726170, 0x0000006d, 0x00040005, 0x00000140, 0x61726170, 0x0000006d, 0x00040005, 0x00000142, + 0x61726170, 0x0000006d, 0x00040047, 0x00000023, 0x00000006, 0x00000004, 0x00030047, 0x00000024, 0x00000003, 0x00040048, + 0x00000024, 0x00000000, 0x00000018, 0x00050048, 0x00000024, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000026, + 0x00000021, 0x00000002, 0x00040047, 0x00000026, 0x00000022, 0x00000000, 0x00040047, 0x0000002c, 0x00000006, 0x00000004, + 0x00030047, 0x0000002d, 0x00000003, 0x00050048, 0x0000002d, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x0000002f, + 0x00000021, 0x00000003, 0x00040047, 0x0000002f, 0x00000022, 0x00000000, 0x00040047, 0x0000003f, 0x00000006, 0x00000004, + 0x00030047, 0x00000040, 0x00000003, 0x00050048, 0x00000040, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x00000040, + 0x00000001, 0x00000023, 0x00000004, 0x00050048, 0x00000040, 0x00000002, 0x00000023, 0x00000008, 0x00040047, 0x00000042, + 0x00000021, 0x00000000, 0x00040047, 0x00000042, 0x00000022, 0x00000000, 0x00040047, 0x0000005a, 0x00000006, 0x00000004, + 0x00030047, 0x0000005b, 0x00000003, 0x00040048, 0x0000005b, 0x00000000, 0x00000018, 0x00050048, 0x0000005b, 0x00000000, + 0x00000023, 0x00000000, 0x00040047, 0x0000005d, 0x00000021, 0x00000001, 0x00040047, 0x0000005d, 0x00000022, 0x00000000, + 0x00050048, 0x00000085, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x00000085, 0x00000001, 0x00000023, 0x00000004, + 0x00050048, 0x00000085, 0x00000002, 0x00000023, 0x00000008, 0x00050048, 0x00000085, 0x00000003, 0x00000023, 0x0000000c, + 0x00050048, 0x00000085, 0x00000004, 0x00000023, 0x00000010, 0x00050048, 0x00000085, 0x00000005, 0x00000023, 0x00000014, + 0x00030047, 0x00000086, 0x00000002, 0x00050048, 0x00000086, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000090, + 0x00000006, 0x00000004, 0x00030047, 0x00000091, 0x00000003, 0x00040048, 0x00000091, 0x00000000, 0x00000018, 0x00050048, + 0x00000091, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000093, 0x00000021, 0x00000002, 0x00040047, 0x00000093, + 0x00000022, 0x00000001, 0x00030047, 0x000000e5, 0x00000002, 0x00050048, 0x000000e5, 0x00000000, 0x0000000b, 0x00000000, + 0x00050048, 0x000000e5, 0x00000001, 0x0000000b, 0x00000001, 0x00050048, 0x000000e5, 0x00000002, 0x0000000b, 0x00000003, + 0x00050048, 0x000000e5, 0x00000003, 0x0000000b, 0x00000004, 0x00030047, 0x000000f6, 0x00000003, 0x00040048, 0x000000f6, + 0x00000000, 0x00000018, 0x00050048, 0x000000f6, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x000000f8, 0x00000021, + 0x00000001, 0x00040047, 0x000000f8, 0x00000022, 0x00000001, 0x00040047, 0x000000fd, 0x0000000b, 0x0000002a, 0x00040047, + 0x0000010a, 0x00000006, 0x00000004, 0x00030047, 0x0000010b, 0x00000003, 0x00040048, 0x0000010b, 0x00000000, 0x00000018, + 0x00050048, 0x0000010b, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x0000010d, 0x00000021, 0x00000000, 0x00040047, + 0x0000010d, 0x00000022, 0x00000001, 0x00020013, 0x00000002, 0x00030021, 0x00000003, 0x00000002, 0x00020014, 0x00000006, + 0x00030021, 0x00000007, 0x00000006, 0x00040015, 0x0000000a, 0x00000020, 0x00000000, 0x00040020, 0x0000000b, 0x00000007, + 0x0000000a, 0x00090021, 0x0000000c, 0x00000002, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, + 0x00040021, 0x00000015, 0x0000000a, 0x0000000b, 0x00040015, 0x00000019, 0x00000020, 0x00000001, 0x00040020, 0x0000001a, + 0x00000007, 0x00000019, 0x00070021, 0x0000001b, 0x00000002, 0x0000000b, 0x0000000b, 0x0000001a, 0x0000000b, 0x0003001d, + 0x00000023, 0x0000000a, 0x0003001e, 0x00000024, 0x00000023, 0x00040020, 0x00000025, 0x00000002, 0x00000024, 0x0004003b, + 0x00000025, 0x00000026, 0x00000002, 0x0004002b, 0x00000019, 0x00000027, 0x00000000, 0x00040020, 0x00000028, 0x00000002, + 0x0000000a, 0x0003001d, 0x0000002c, 0x0000000a, 0x0003001e, 0x0000002d, 0x0000002c, 0x00040020, 0x0000002e, 0x00000002, + 0x0000002d, 0x0004003b, 0x0000002e, 0x0000002f, 0x00000002, 0x0004002b, 0x0000000a, 0x00000032, 0x00000001, 0x0004002b, + 0x0000000a, 0x00000033, 0x00000000, 0x0004002b, 0x0000000a, 0x00000036, 0x00000006, 0x0003001d, 0x0000003f, 0x0000000a, + 0x0005001e, 0x00000040, 0x0000000a, 0x0000000a, 0x0000003f, 0x00040020, 0x00000041, 0x00000002, 0x00000040, 0x0004003b, + 0x00000041, 0x00000042, 0x00000002, 0x0004002b, 0x00000019, 0x00000043, 0x00000001, 0x0004002b, 0x0000000a, 0x00000045, + 0x00000010, 0x0004002b, 0x00000019, 0x00000053, 0x00000002, 0x0004002b, 0x0000000a, 0x00000058, 0x00000007, 0x0003001d, + 0x0000005a, 0x0000000a, 0x0003001e, 0x0000005b, 0x0000005a, 0x00040020, 0x0000005c, 0x00000002, 0x0000005b, 0x0004003b, + 0x0000005c, 0x0000005d, 0x00000002, 0x0004002b, 0x0000000a, 0x00000062, 0x00000008, 0x0004002b, 0x0000000a, 0x00000068, + 0x00000009, 0x0004002b, 0x0000000a, 0x0000006d, 0x0000000a, 0x0004002b, 0x0000000a, 0x00000072, 0x0000000b, 0x0004002b, + 0x0000000a, 0x00000077, 0x0000000c, 0x0004002b, 0x0000000a, 0x0000007c, 0x0000000d, 0x0004002b, 0x0000000a, 0x00000081, + 0x0000000e, 0x0008001e, 0x00000085, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x0003001e, + 0x00000086, 0x00000085, 0x00040020, 0x00000087, 0x00000009, 0x00000086, 0x0004003b, 0x00000087, 0x00000088, 0x00000009, + 0x00040020, 0x00000089, 0x00000009, 0x0000000a, 0x0004002b, 0x0000000a, 0x0000008c, 0x00000020, 0x0003001d, 0x00000090, + 0x0000000a, 0x0003001e, 0x00000091, 0x00000090, 0x00040020, 0x00000092, 0x00000002, 0x00000091, 0x0004003b, 0x00000092, + 0x00000093, 0x00000002, 0x0004002b, 0x0000000a, 0x000000a0, 0x00000002, 0x0004002b, 0x0000000a, 0x000000ad, 0x0000ffff, + 0x0004002b, 0x0000000a, 0x000000b8, 0x00000004, 0x0004002b, 0x0000000a, 0x000000c5, 0x000000ff, 0x00030016, 0x000000e2, + 0x00000020, 0x00040017, 0x000000e3, 0x000000e2, 0x00000004, 0x0004001c, 0x000000e4, 0x000000e2, 0x00000032, 0x0006001e, + 0x000000e5, 0x000000e3, 0x000000e2, 0x000000e4, 0x000000e4, 0x00040020, 0x000000e6, 0x00000003, 0x000000e5, 0x0004003b, + 0x000000e6, 0x000000e7, 0x00000003, 0x0004002b, 0x000000e2, 0x000000e8, 0x3f800000, 0x00040020, 0x000000e9, 0x00000003, + 0x000000e2, 0x0004002b, 0x00000019, 0x000000f2, 0x00000004, 0x0003001e, 0x000000f6, 0x0000000a, 0x00040020, 0x000000f7, + 0x00000002, 0x000000f6, 0x0004003b, 0x000000f7, 0x000000f8, 0x00000002, 0x00040020, 0x000000fc, 0x00000001, 0x00000019, + 0x0004003b, 0x000000fc, 0x000000fd, 0x00000001, 0x0003001d, 0x0000010a, 0x0000000a, 0x0003001e, 0x0000010b, 0x0000010a, + 0x00040020, 0x0000010c, 0x00000002, 0x0000010b, 0x0004003b, 0x0000010c, 0x0000010d, 0x00000002, 0x0004002b, 0x00000019, + 0x0000011e, 0x00000003, 0x0004002b, 0x0000000a, 0x00000136, 0x00000003, 0x0004002b, 0x00000019, 0x0000013b, 0x00000005, + 0x00050036, 0x00000002, 0x00000004, 0x00000000, 0x00000003, 0x000200f8, 0x00000005, 0x0004003b, 0x0000000b, 0x000000eb, + 0x00000007, 0x0004003b, 0x0000000b, 0x00000100, 0x00000007, 0x0004003b, 0x0000000b, 0x0000013c, 0x00000007, 0x0004003b, + 0x0000000b, 0x0000013e, 0x00000007, 0x0004003b, 0x0000001a, 0x00000140, 0x00000007, 0x0004003b, 0x0000000b, 0x00000142, + 0x00000007, 0x00050041, 0x000000e9, 0x000000ea, 0x000000e7, 0x00000043, 0x0003003e, 0x000000ea, 0x000000e8, 0x0003003e, + 0x000000eb, 0x00000033, 0x00060041, 0x00000089, 0x000000ec, 0x00000088, 0x00000027, 0x00000027, 0x0004003d, 0x0000000a, + 0x000000ed, 0x000000ec, 0x000500c7, 0x0000000a, 0x000000ee, 0x000000ed, 0x00000032, 0x000500aa, 0x00000006, 0x000000ef, + 0x000000ee, 0x00000033, 0x000300f7, 0x000000f1, 0x00000000, 0x000400fa, 0x000000ef, 0x000000f0, 0x000000f5, 0x000200f8, + 0x000000f0, 0x00060041, 0x00000089, 0x000000f3, 0x00000088, 0x00000027, 0x000000f2, 0x0004003d, 0x0000000a, 0x000000f4, + 0x000000f3, 0x0003003e, 0x000000eb, 0x000000f4, 0x000200f9, 0x000000f1, 0x000200f8, 0x000000f5, 0x00050041, 0x00000028, + 0x000000f9, 0x000000f8, 0x00000027, 0x0004003d, 0x0000000a, 0x000000fa, 0x000000f9, 0x0003003e, 0x000000eb, 0x000000fa, + 0x000200f9, 0x000000f1, 0x000200f8, 0x000000f1, 0x0004003d, 0x00000019, 0x000000fe, 0x000000fd, 0x0004007c, 0x0000000a, + 0x000000ff, 0x000000fe, 0x0003003e, 0x00000100, 0x00000033, 0x000200f9, 0x00000101, 0x000200f8, 0x00000101, 0x000400f6, + 0x00000103, 0x00000104, 0x00000000, 0x000200f9, 0x00000105, 0x000200f8, 0x00000105, 0x0004003d, 0x0000000a, 0x00000106, + 0x00000100, 0x0004003d, 0x0000000a, 0x00000107, 0x000000eb, 0x000500b0, 0x00000006, 0x00000108, 0x00000106, 0x00000107, + 0x000400fa, 0x00000108, 0x00000102, 0x00000103, 0x000200f8, 0x00000102, 0x0004003d, 0x0000000a, 0x0000010e, 0x00000100, + 0x00060041, 0x00000089, 0x0000010f, 0x00000088, 0x00000027, 0x00000053, 0x0004003d, 0x0000000a, 0x00000110, 0x0000010f, + 0x00050084, 0x0000000a, 0x00000111, 0x0000010e, 0x00000110, 0x00060041, 0x00000028, 0x00000113, 0x0000010d, 0x00000027, + 0x00000111, 0x0004003d, 0x0000000a, 0x00000114, 0x00000113, 0x00060041, 0x00000089, 0x00000117, 0x00000088, 0x00000027, + 0x00000053, 0x0004003d, 0x0000000a, 0x00000118, 0x00000117, 0x00050084, 0x0000000a, 0x00000119, 0x0000010e, 0x00000118, + 0x00050080, 0x0000000a, 0x0000011a, 0x00000119, 0x000000a0, 0x00060041, 0x00000028, 0x0000011b, 0x0000010d, 0x00000027, + 0x0000011a, 0x0004003d, 0x0000000a, 0x0000011c, 0x0000011b, 0x00060041, 0x00000089, 0x0000011f, 0x00000088, 0x00000027, + 0x0000011e, 0x0004003d, 0x0000000a, 0x00000120, 0x0000011f, 0x000500b0, 0x00000006, 0x00000121, 0x000000ff, 0x00000120, + 0x000300f7, 0x00000123, 0x00000000, 0x000400fa, 0x00000121, 0x00000122, 0x00000123, 0x000200f8, 0x00000122, 0x000500ae, + 0x00000006, 0x00000126, 0x000000ff, 0x0000011c, 0x000300f7, 0x00000128, 0x00000000, 0x000400fa, 0x00000126, 0x00000127, + 0x00000128, 0x000200f8, 0x00000127, 0x00050080, 0x0000000a, 0x0000012c, 0x0000011c, 0x00000114, 0x000500b0, 0x00000006, + 0x0000012d, 0x000000ff, 0x0000012c, 0x000200f9, 0x00000128, 0x000200f8, 0x00000128, 0x000700f5, 0x00000006, 0x0000012e, + 0x00000126, 0x00000122, 0x0000012d, 0x00000127, 0x000300f7, 0x00000130, 0x00000000, 0x000400fa, 0x0000012e, 0x0000012f, + 0x00000130, 0x000200f8, 0x0000012f, 0x0004003d, 0x0000000a, 0x00000132, 0x00000100, 0x00060041, 0x00000089, 0x00000133, + 0x00000088, 0x00000027, 0x00000053, 0x0004003d, 0x0000000a, 0x00000134, 0x00000133, 0x00050084, 0x0000000a, 0x00000135, + 0x00000132, 0x00000134, 0x00050080, 0x0000000a, 0x00000137, 0x00000135, 0x00000136, 0x00060041, 0x00000028, 0x00000138, + 0x0000010d, 0x00000027, 0x00000137, 0x0004003d, 0x0000000a, 0x00000139, 0x00000138, 0x0004007c, 0x00000019, 0x0000013a, + 0x00000139, 0x0003003e, 0x0000013c, 0x00000132, 0x0003003e, 0x0000013e, 0x000000ff, 0x0003003e, 0x00000140, 0x0000013a, + 0x00060041, 0x00000089, 0x00000143, 0x00000088, 0x00000027, 0x0000013b, 0x0004003d, 0x0000000a, 0x00000144, 0x00000143, + 0x0003003e, 0x00000142, 0x00000144, 0x00080039, 0x00000002, 0x00000145, 0x00000020, 0x0000013c, 0x0000013e, 0x00000140, + 0x00000142, 0x000200f9, 0x00000130, 0x000200f8, 0x00000130, 0x000200f9, 0x00000123, 0x000200f8, 0x00000123, 0x000200f9, + 0x00000104, 0x000200f8, 0x00000104, 0x0004003d, 0x0000000a, 0x00000146, 0x00000100, 0x00050080, 0x0000000a, 0x00000147, + 0x00000146, 0x00000043, 0x0003003e, 0x00000100, 0x00000147, 0x000200f9, 0x00000101, 0x000200f8, 0x00000103, 0x000100fd, + 0x00010038, 0x00050036, 0x00000006, 0x00000008, 0x00000000, 0x00000007, 0x000200f8, 0x00000009, 0x00060041, 0x00000028, + 0x00000029, 0x00000026, 0x00000027, 0x00000027, 0x0004003d, 0x0000000a, 0x0000002a, 0x00000029, 0x00060041, 0x00000028, + 0x00000031, 0x0000002f, 0x00000027, 0x0000002a, 0x000700ea, 0x0000000a, 0x00000034, 0x00000031, 0x00000032, 0x00000033, + 0x00000032, 0x000500ae, 0x00000006, 0x00000037, 0x00000034, 0x00000036, 0x000200fe, 0x00000037, 0x00010038, 0x00050036, + 0x00000002, 0x00000013, 0x00000000, 0x0000000c, 0x00030037, 0x0000000b, 0x0000000d, 0x00030037, 0x0000000b, 0x0000000e, + 0x00030037, 0x0000000b, 0x0000000f, 0x00030037, 0x0000000b, 0x00000010, 0x00030037, 0x0000000b, 0x00000011, 0x00030037, + 0x0000000b, 0x00000012, 0x000200f8, 0x00000014, 0x00040039, 0x00000006, 0x0000003a, 0x00000008, 0x000300f7, 0x0000003c, + 0x00000000, 0x000400fa, 0x0000003a, 0x0000003b, 0x0000003c, 0x000200f8, 0x0000003b, 0x000100fd, 0x000200f8, 0x0000003c, + 0x00050041, 0x00000028, 0x00000044, 0x00000042, 0x00000043, 0x000700ea, 0x0000000a, 0x00000046, 0x00000044, 0x00000032, + 0x00000033, 0x00000045, 0x00050080, 0x0000000a, 0x0000004a, 0x00000046, 0x00000045, 0x00050044, 0x0000000a, 0x0000004b, + 0x00000042, 0x00000002, 0x0004007c, 0x00000019, 0x0000004c, 0x0000004b, 0x0004007c, 0x0000000a, 0x0000004d, 0x0000004c, + 0x000500ac, 0x00000006, 0x0000004e, 0x0000004a, 0x0000004d, 0x000300f7, 0x00000051, 0x00000000, 0x000400fa, 0x0000004e, + 0x00000050, 0x00000051, 0x000200f8, 0x00000050, 0x000100fd, 0x000200f8, 0x00000051, 0x00060041, 0x00000028, 0x00000056, + 0x00000042, 0x00000053, 0x00000046, 0x0003003e, 0x00000056, 0x00000045, 0x00050080, 0x0000000a, 0x00000059, 0x00000046, + 0x00000058, 0x00060041, 0x00000028, 0x0000005e, 0x0000005d, 0x00000027, 0x00000027, 0x0004003d, 0x0000000a, 0x0000005f, + 0x0000005e, 0x00060041, 0x00000028, 0x00000060, 0x00000042, 0x00000053, 0x00000059, 0x0003003e, 0x00000060, 0x0000005f, + 0x00050080, 0x0000000a, 0x00000063, 0x00000046, 0x00000062, 0x00060041, 0x00000028, 0x00000064, 0x00000026, 0x00000027, + 0x00000027, 0x0004003d, 0x0000000a, 0x00000065, 0x00000064, 0x00060041, 0x00000028, 0x00000066, 0x00000042, 0x00000053, + 0x00000063, 0x0003003e, 0x00000066, 0x00000065, 0x00050080, 0x0000000a, 0x00000069, 0x00000046, 0x00000068, 0x0004003d, + 0x0000000a, 0x0000006a, 0x0000000d, 0x00060041, 0x00000028, 0x0000006b, 0x00000042, 0x00000053, 0x00000069, 0x0003003e, + 0x0000006b, 0x0000006a, 0x00050080, 0x0000000a, 0x0000006e, 0x00000046, 0x0000006d, 0x0004003d, 0x0000000a, 0x0000006f, + 0x0000000e, 0x00060041, 0x00000028, 0x00000070, 0x00000042, 0x00000053, 0x0000006e, 0x0003003e, 0x00000070, 0x0000006f, + 0x00050080, 0x0000000a, 0x00000073, 0x00000046, 0x00000072, 0x0004003d, 0x0000000a, 0x00000074, 0x0000000f, 0x00060041, + 0x00000028, 0x00000075, 0x00000042, 0x00000053, 0x00000073, 0x0003003e, 0x00000075, 0x00000074, 0x00050080, 0x0000000a, + 0x00000078, 0x00000046, 0x00000077, 0x0004003d, 0x0000000a, 0x00000079, 0x00000010, 0x00060041, 0x00000028, 0x0000007a, + 0x00000042, 0x00000053, 0x00000078, 0x0003003e, 0x0000007a, 0x00000079, 0x00050080, 0x0000000a, 0x0000007d, 0x00000046, + 0x0000007c, 0x0004003d, 0x0000000a, 0x0000007e, 0x00000011, 0x00060041, 0x00000028, 0x0000007f, 0x00000042, 0x00000053, + 0x0000007d, 0x0003003e, 0x0000007f, 0x0000007e, 0x00050080, 0x0000000a, 0x00000082, 0x00000046, 0x00000081, 0x0004003d, + 0x0000000a, 0x00000083, 0x00000012, 0x00060041, 0x00000028, 0x00000084, 0x00000042, 0x00000053, 0x00000082, 0x0003003e, + 0x00000084, 0x00000083, 0x000100fd, 0x00010038, 0x00050036, 0x0000000a, 0x00000017, 0x00000000, 0x00000015, 0x00030037, + 0x0000000b, 0x00000016, 0x000200f8, 0x00000018, 0x00060041, 0x00000089, 0x0000008a, 0x00000088, 0x00000027, 0x00000043, + 0x0004003d, 0x0000000a, 0x0000008b, 0x0000008a, 0x000500aa, 0x00000006, 0x0000008d, 0x0000008b, 0x0000008c, 0x000300f7, + 0x0000008f, 0x00000000, 0x000400fa, 0x0000008d, 0x0000008e, 0x00000098, 0x000200f8, 0x0000008e, 0x0004003d, 0x0000000a, + 0x00000094, 0x00000016, 0x00060041, 0x00000028, 0x00000095, 0x00000093, 0x00000027, 0x00000094, 0x0004003d, 0x0000000a, + 0x00000096, 0x00000095, 0x000200fe, 0x00000096, 0x000200f8, 0x00000098, 0x00060041, 0x00000089, 0x00000099, 0x00000088, + 0x00000027, 0x00000043, 0x0004003d, 0x0000000a, 0x0000009a, 0x00000099, 0x000500aa, 0x00000006, 0x0000009b, 0x0000009a, + 0x00000045, 0x000300f7, 0x0000009d, 0x00000000, 0x000400fa, 0x0000009b, 0x0000009c, 0x000000b0, 0x000200f8, 0x0000009c, + 0x0004003d, 0x0000000a, 0x0000009f, 0x00000016, 0x00050086, 0x0000000a, 0x000000a1, 0x0000009f, 0x000000a0, 0x00060041, + 0x00000028, 0x000000a4, 0x00000093, 0x00000027, 0x000000a1, 0x0004003d, 0x0000000a, 0x000000a5, 0x000000a4, 0x0004003d, + 0x0000000a, 0x000000a7, 0x00000016, 0x00050089, 0x0000000a, 0x000000a8, 0x000000a7, 0x000000a0, 0x00050084, 0x0000000a, + 0x000000a9, 0x000000a8, 0x00000045, 0x000500c2, 0x0000000a, 0x000000ac, 0x000000a5, 0x000000a9, 0x000500c7, 0x0000000a, + 0x000000ae, 0x000000ac, 0x000000ad, 0x000200fe, 0x000000ae, 0x000200f8, 0x000000b0, 0x00060041, 0x00000089, 0x000000b1, + 0x00000088, 0x00000027, 0x00000043, 0x0004003d, 0x0000000a, 0x000000b2, 0x000000b1, 0x000500aa, 0x00000006, 0x000000b3, + 0x000000b2, 0x00000062, 0x000300f7, 0x000000b5, 0x00000000, 0x000400fa, 0x000000b3, 0x000000b4, 0x000000b5, 0x000200f8, + 0x000000b4, 0x0004003d, 0x0000000a, 0x000000b7, 0x00000016, 0x00050086, 0x0000000a, 0x000000b9, 0x000000b7, 0x000000b8, + 0x00060041, 0x00000028, 0x000000bc, 0x00000093, 0x00000027, 0x000000b9, 0x0004003d, 0x0000000a, 0x000000bd, 0x000000bc, + 0x0004003d, 0x0000000a, 0x000000bf, 0x00000016, 0x00050089, 0x0000000a, 0x000000c0, 0x000000bf, 0x000000b8, 0x00050084, + 0x0000000a, 0x000000c1, 0x000000c0, 0x00000062, 0x000500c2, 0x0000000a, 0x000000c4, 0x000000bd, 0x000000c1, 0x000500c7, + 0x0000000a, 0x000000c6, 0x000000c4, 0x000000c5, 0x000200fe, 0x000000c6, 0x000200f8, 0x000000b5, 0x000200f9, 0x0000009d, + 0x000200f8, 0x0000009d, 0x000200f9, 0x0000008f, 0x000200f8, 0x0000008f, 0x000200fe, 0x00000033, 0x00010038, 0x00050036, + 0x00000002, 0x00000020, 0x00000000, 0x0000001b, 0x00030037, 0x0000000b, 0x0000001c, 0x00030037, 0x0000000b, 0x0000001d, + 0x00030037, 0x0000001a, 0x0000001e, 0x00030037, 0x0000000b, 0x0000001f, 0x000200f8, 0x00000021, 0x0004003b, 0x0000000b, + 0x000000cb, 0x00000007, 0x0004003b, 0x0000000b, 0x000000d8, 0x00000007, 0x0004003b, 0x0000000b, 0x000000d9, 0x00000007, + 0x0004003b, 0x0000000b, 0x000000da, 0x00000007, 0x0004003b, 0x0000000b, 0x000000dc, 0x00000007, 0x0004003b, 0x0000000b, + 0x000000de, 0x00000007, 0x0004003b, 0x0000000b, 0x000000df, 0x00000007, 0x0004003d, 0x0000000a, 0x000000cc, 0x0000001d, + 0x0003003e, 0x000000cb, 0x000000cc, 0x00050039, 0x0000000a, 0x000000cd, 0x00000017, 0x000000cb, 0x0004003d, 0x00000019, + 0x000000ce, 0x0000001e, 0x0004007c, 0x0000000a, 0x000000cf, 0x000000ce, 0x00050080, 0x0000000a, 0x000000d0, 0x000000cd, + 0x000000cf, 0x0004003d, 0x0000000a, 0x000000d2, 0x0000001f, 0x000500ae, 0x00000006, 0x000000d3, 0x000000d0, 0x000000d2, + 0x000300f7, 0x000000d5, 0x00000000, 0x000400fa, 0x000000d3, 0x000000d4, 0x000000d5, 0x000200f8, 0x000000d4, 0x0004003d, + 0x00000019, 0x000000d6, 0x0000001e, 0x0004007c, 0x0000000a, 0x000000d7, 0x000000d6, 0x0003003e, 0x000000d8, 0x000000b8, + 0x0003003e, 0x000000d9, 0x00000068, 0x0004003d, 0x0000000a, 0x000000db, 0x0000001c, 0x0003003e, 0x000000da, 0x000000db, + 0x0004003d, 0x0000000a, 0x000000dd, 0x0000001d, 0x0003003e, 0x000000dc, 0x000000dd, 0x0003003e, 0x000000de, 0x000000d7, + 0x0003003e, 0x000000df, 0x000000d0, 0x000a0039, 0x00000002, 0x000000e1, 0x00000013, 0x000000d8, 0x000000d9, 0x000000da, + 0x000000dc, 0x000000de, 0x000000df, 0x000200f9, 0x000000d5, 0x000200f8, 0x000000d5, 0x000100fd, 0x00010038, +}; diff --git a/layers/vulkan/generated/cmd_validation_draw_indexed_indirect_vertex_buffer_vert.h b/layers/vulkan/generated/cmd_validation_draw_indexed_indirect_vertex_buffer_vert.h new file mode 100644 index 00000000000..95a78c6f59b --- /dev/null +++ b/layers/vulkan/generated/cmd_validation_draw_indexed_indirect_vertex_buffer_vert.h @@ -0,0 +1,30 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See generate_spirv.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2021-2024 The Khronos Group Inc. + * Copyright (c) 2021-2024 Valve Corporation + * Copyright (c) 2021-2024 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************/ + +#pragma once + +#include + +// To view SPIR-V, copy contents of array and paste in https://www.khronos.org/spir/visualizer/ +extern const uint32_t cmd_validation_draw_indexed_indirect_vertex_buffer_vert_size; +extern const uint32_t cmd_validation_draw_indexed_indirect_vertex_buffer_vert[]; diff --git a/layers/vulkan/generated/cmd_validation_draw_indexed_vert.cpp b/layers/vulkan/generated/cmd_validation_draw_indexed_vert.cpp new file mode 100644 index 00000000000..5057eb1fa57 --- /dev/null +++ b/layers/vulkan/generated/cmd_validation_draw_indexed_vert.cpp @@ -0,0 +1,179 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See generate_spirv.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2021-2024 The Khronos Group Inc. + * Copyright (c) 2021-2024 Valve Corporation + * Copyright (c) 2021-2024 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************/ + +#include "cmd_validation_draw_indexed_vert.h" + +// To view SPIR-V, copy contents of array and paste in https://www.khronos.org/spir/visualizer/ +[[maybe_unused]] const uint32_t cmd_validation_draw_indexed_vert_size = 1495; +[[maybe_unused]] const uint32_t cmd_validation_draw_indexed_vert[1495] = { + 0x07230203, 0x00010000, 0x0008000b, 0x000000f4, 0x00000000, 0x00020011, 0x00000001, 0x0006000b, 0x00000001, 0x4c534c47, + 0x6474732e, 0x3035342e, 0x00000000, 0x0003000e, 0x00000000, 0x00000001, 0x0007000f, 0x00000000, 0x00000004, 0x6e69616d, + 0x00000000, 0x000000e2, 0x000000e8, 0x00030003, 0x00000002, 0x000001c2, 0x00070004, 0x415f4c47, 0x675f4252, 0x735f7570, + 0x65646168, 0x6e695f72, 0x00343674, 0x000a0004, 0x475f4c47, 0x4c474f4f, 0x70635f45, 0x74735f70, 0x5f656c79, 0x656e696c, + 0x7269645f, 0x69746365, 0x00006576, 0x00080004, 0x475f4c47, 0x4c474f4f, 0x6e695f45, 0x64756c63, 0x69645f65, 0x74636572, + 0x00657669, 0x00040005, 0x00000004, 0x6e69616d, 0x00000000, 0x00090005, 0x00000008, 0x4378614d, 0x7245646d, 0x73726f72, + 0x6e756f43, 0x61655274, 0x64656863, 0x00000028, 0x000b0005, 0x00000013, 0x61757047, 0x676f4c76, 0x6f727245, 0x75283472, + 0x31753b31, 0x3b31753b, 0x753b3175, 0x31753b31, 0x0000003b, 0x00050005, 0x0000000d, 0x6f727265, 0x72675f72, 0x0070756f, + 0x00060005, 0x0000000e, 0x6f727265, 0x75735f72, 0x6f635f62, 0x00006564, 0x00040005, 0x0000000f, 0x61726170, 0x00305f6d, + 0x00040005, 0x00000010, 0x61726170, 0x00315f6d, 0x00040005, 0x00000011, 0x61726170, 0x00325f6d, 0x00040005, 0x00000012, + 0x61726170, 0x00335f6d, 0x00080005, 0x00000017, 0x5f746567, 0x74726576, 0x695f7865, 0x7865646e, 0x3b317528, 0x00000000, + 0x00030005, 0x00000016, 0x00000069, 0x000a0005, 0x0000001d, 0x696c6156, 0x65746164, 0x74726556, 0x6e497865, 0x28786564, + 0x753b3175, 0x31753b31, 0x0000003b, 0x00070005, 0x0000001a, 0x65646e69, 0x75625f78, 0x72656666, 0x66666f5f, 0x00746573, + 0x00060005, 0x0000001b, 0x74726576, 0x6f5f7865, 0x65736666, 0x00000074, 0x000b0005, 0x0000001c, 0x6c616d73, 0x7473656c, + 0x7265765f, 0x5f786574, 0x72747461, 0x74756269, 0x635f7365, 0x746e756f, 0x00000000, 0x00070005, 0x00000021, 0x6f736552, + 0x65637275, 0x65646e49, 0x66754278, 0x00726566, 0x00070006, 0x00000021, 0x00000000, 0x6f736572, 0x65637275, 0x646e695f, + 0x00007865, 0x00030005, 0x00000023, 0x00000000, 0x00080005, 0x0000002b, 0x45646d43, 0x726f7272, 0x756f4373, 0x7542746e, + 0x72656666, 0x00000000, 0x00080006, 0x0000002b, 0x00000000, 0x5f646d63, 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, + 0x00030005, 0x0000002d, 0x00000000, 0x00050005, 0x0000003e, 0x6f727245, 0x66754272, 0x00726566, 0x00050006, 0x0000003e, + 0x00000000, 0x67616c66, 0x00000073, 0x00070006, 0x0000003e, 0x00000001, 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, + 0x00070006, 0x0000003e, 0x00000002, 0x6f727265, 0x625f7372, 0x65666675, 0x00000072, 0x00030005, 0x00000040, 0x00000000, + 0x00070005, 0x00000059, 0x69746341, 0x6e496e6f, 0x42786564, 0x65666675, 0x00000072, 0x00070006, 0x00000059, 0x00000000, + 0x69746361, 0x695f6e6f, 0x7865646e, 0x00000000, 0x00030005, 0x0000005b, 0x00000000, 0x00070005, 0x00000083, 0x65646e49, + 0x44646578, 0x50776172, 0x44687375, 0x00617461, 0x000c0006, 0x00000083, 0x00000000, 0x6c616d73, 0x7473656c, 0x7265765f, + 0x5f786574, 0x72747461, 0x74756269, 0x635f7365, 0x746e756f, 0x00000000, 0x00060006, 0x00000083, 0x00000001, 0x65646e69, + 0x69775f78, 0x00687464, 0x00070006, 0x00000083, 0x00000002, 0x74726576, 0x6f5f7865, 0x65736666, 0x00000074, 0x00050005, + 0x00000084, 0x66696e55, 0x496d726f, 0x006f666e, 0x00040006, 0x00000084, 0x00000000, 0x00006370, 0x00030005, 0x00000086, + 0x00000000, 0x00060005, 0x0000008f, 0x65646e49, 0x66754278, 0x33726566, 0x00000032, 0x00070006, 0x0000008f, 0x00000000, + 0x65646e69, 0x75625f78, 0x72656666, 0x00000000, 0x00030005, 0x00000091, 0x00000000, 0x00040005, 0x000000c9, 0x61726170, + 0x0000006d, 0x00040005, 0x000000d3, 0x61726170, 0x0000006d, 0x00040005, 0x000000d4, 0x61726170, 0x0000006d, 0x00040005, + 0x000000d5, 0x61726170, 0x0000006d, 0x00040005, 0x000000d7, 0x61726170, 0x0000006d, 0x00040005, 0x000000d9, 0x61726170, + 0x0000006d, 0x00040005, 0x000000db, 0x61726170, 0x0000006d, 0x00060005, 0x000000e0, 0x505f6c67, 0x65567265, 0x78657472, + 0x00000000, 0x00060006, 0x000000e0, 0x00000000, 0x505f6c67, 0x7469736f, 0x006e6f69, 0x00070006, 0x000000e0, 0x00000001, + 0x505f6c67, 0x746e696f, 0x657a6953, 0x00000000, 0x00070006, 0x000000e0, 0x00000002, 0x435f6c67, 0x4470696c, 0x61747369, + 0x0065636e, 0x00070006, 0x000000e0, 0x00000003, 0x435f6c67, 0x446c6c75, 0x61747369, 0x0065636e, 0x00030005, 0x000000e2, + 0x00000000, 0x00060005, 0x000000e8, 0x565f6c67, 0x65747265, 0x646e4978, 0x00007865, 0x00040005, 0x000000eb, 0x61726170, + 0x0000006d, 0x00040005, 0x000000ed, 0x61726170, 0x0000006d, 0x00040005, 0x000000f0, 0x61726170, 0x0000006d, 0x00040047, + 0x00000020, 0x00000006, 0x00000004, 0x00030047, 0x00000021, 0x00000003, 0x00040048, 0x00000021, 0x00000000, 0x00000018, + 0x00050048, 0x00000021, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000023, 0x00000021, 0x00000002, 0x00040047, + 0x00000023, 0x00000022, 0x00000000, 0x00040047, 0x0000002a, 0x00000006, 0x00000004, 0x00030047, 0x0000002b, 0x00000003, + 0x00050048, 0x0000002b, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x0000002d, 0x00000021, 0x00000003, 0x00040047, + 0x0000002d, 0x00000022, 0x00000000, 0x00040047, 0x0000003d, 0x00000006, 0x00000004, 0x00030047, 0x0000003e, 0x00000003, + 0x00050048, 0x0000003e, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x0000003e, 0x00000001, 0x00000023, 0x00000004, + 0x00050048, 0x0000003e, 0x00000002, 0x00000023, 0x00000008, 0x00040047, 0x00000040, 0x00000021, 0x00000000, 0x00040047, + 0x00000040, 0x00000022, 0x00000000, 0x00040047, 0x00000058, 0x00000006, 0x00000004, 0x00030047, 0x00000059, 0x00000003, + 0x00040048, 0x00000059, 0x00000000, 0x00000018, 0x00050048, 0x00000059, 0x00000000, 0x00000023, 0x00000000, 0x00040047, + 0x0000005b, 0x00000021, 0x00000001, 0x00040047, 0x0000005b, 0x00000022, 0x00000000, 0x00050048, 0x00000083, 0x00000000, + 0x00000023, 0x00000000, 0x00050048, 0x00000083, 0x00000001, 0x00000023, 0x00000004, 0x00050048, 0x00000083, 0x00000002, + 0x00000023, 0x00000008, 0x00030047, 0x00000084, 0x00000002, 0x00050048, 0x00000084, 0x00000000, 0x00000023, 0x00000000, + 0x00040047, 0x0000008e, 0x00000006, 0x00000004, 0x00030047, 0x0000008f, 0x00000003, 0x00040048, 0x0000008f, 0x00000000, + 0x00000018, 0x00050048, 0x0000008f, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000091, 0x00000021, 0x00000002, + 0x00040047, 0x00000091, 0x00000022, 0x00000001, 0x00030047, 0x000000e0, 0x00000002, 0x00050048, 0x000000e0, 0x00000000, + 0x0000000b, 0x00000000, 0x00050048, 0x000000e0, 0x00000001, 0x0000000b, 0x00000001, 0x00050048, 0x000000e0, 0x00000002, + 0x0000000b, 0x00000003, 0x00050048, 0x000000e0, 0x00000003, 0x0000000b, 0x00000004, 0x00040047, 0x000000e8, 0x0000000b, + 0x0000002a, 0x00020013, 0x00000002, 0x00030021, 0x00000003, 0x00000002, 0x00020014, 0x00000006, 0x00030021, 0x00000007, + 0x00000006, 0x00040015, 0x0000000a, 0x00000020, 0x00000000, 0x00040020, 0x0000000b, 0x00000007, 0x0000000a, 0x00090021, + 0x0000000c, 0x00000002, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x00040021, 0x00000015, + 0x0000000a, 0x0000000b, 0x00060021, 0x00000019, 0x00000002, 0x0000000b, 0x0000000b, 0x0000000b, 0x0003001d, 0x00000020, + 0x0000000a, 0x0003001e, 0x00000021, 0x00000020, 0x00040020, 0x00000022, 0x00000002, 0x00000021, 0x0004003b, 0x00000022, + 0x00000023, 0x00000002, 0x00040015, 0x00000024, 0x00000020, 0x00000001, 0x0004002b, 0x00000024, 0x00000025, 0x00000000, + 0x00040020, 0x00000026, 0x00000002, 0x0000000a, 0x0003001d, 0x0000002a, 0x0000000a, 0x0003001e, 0x0000002b, 0x0000002a, + 0x00040020, 0x0000002c, 0x00000002, 0x0000002b, 0x0004003b, 0x0000002c, 0x0000002d, 0x00000002, 0x0004002b, 0x0000000a, + 0x00000030, 0x00000001, 0x0004002b, 0x0000000a, 0x00000031, 0x00000000, 0x0004002b, 0x0000000a, 0x00000034, 0x00000006, + 0x0003001d, 0x0000003d, 0x0000000a, 0x0005001e, 0x0000003e, 0x0000000a, 0x0000000a, 0x0000003d, 0x00040020, 0x0000003f, + 0x00000002, 0x0000003e, 0x0004003b, 0x0000003f, 0x00000040, 0x00000002, 0x0004002b, 0x00000024, 0x00000041, 0x00000001, + 0x0004002b, 0x0000000a, 0x00000043, 0x00000010, 0x0004002b, 0x00000024, 0x00000051, 0x00000002, 0x0004002b, 0x0000000a, + 0x00000056, 0x00000007, 0x0003001d, 0x00000058, 0x0000000a, 0x0003001e, 0x00000059, 0x00000058, 0x00040020, 0x0000005a, + 0x00000002, 0x00000059, 0x0004003b, 0x0000005a, 0x0000005b, 0x00000002, 0x0004002b, 0x0000000a, 0x00000060, 0x00000008, + 0x0004002b, 0x0000000a, 0x00000066, 0x00000009, 0x0004002b, 0x0000000a, 0x0000006b, 0x0000000a, 0x0004002b, 0x0000000a, + 0x00000070, 0x0000000b, 0x0004002b, 0x0000000a, 0x00000075, 0x0000000c, 0x0004002b, 0x0000000a, 0x0000007a, 0x0000000d, + 0x0004002b, 0x0000000a, 0x0000007f, 0x0000000e, 0x0005001e, 0x00000083, 0x0000000a, 0x0000000a, 0x0000000a, 0x0003001e, + 0x00000084, 0x00000083, 0x00040020, 0x00000085, 0x00000009, 0x00000084, 0x0004003b, 0x00000085, 0x00000086, 0x00000009, + 0x00040020, 0x00000087, 0x00000009, 0x0000000a, 0x0004002b, 0x0000000a, 0x0000008a, 0x00000020, 0x0003001d, 0x0000008e, + 0x0000000a, 0x0003001e, 0x0000008f, 0x0000008e, 0x00040020, 0x00000090, 0x00000002, 0x0000008f, 0x0004003b, 0x00000090, + 0x00000091, 0x00000002, 0x0004002b, 0x0000000a, 0x0000009e, 0x00000002, 0x0004002b, 0x0000000a, 0x000000ab, 0x0000ffff, + 0x0004002b, 0x0000000a, 0x000000b6, 0x00000004, 0x0004002b, 0x0000000a, 0x000000c3, 0x000000ff, 0x00030016, 0x000000dd, + 0x00000020, 0x00040017, 0x000000de, 0x000000dd, 0x00000004, 0x0004001c, 0x000000df, 0x000000dd, 0x00000030, 0x0006001e, + 0x000000e0, 0x000000de, 0x000000dd, 0x000000df, 0x000000df, 0x00040020, 0x000000e1, 0x00000003, 0x000000e0, 0x0004003b, + 0x000000e1, 0x000000e2, 0x00000003, 0x0004002b, 0x000000dd, 0x000000e3, 0x3f800000, 0x00040020, 0x000000e4, 0x00000003, + 0x000000dd, 0x00040020, 0x000000e7, 0x00000001, 0x00000024, 0x0004003b, 0x000000e7, 0x000000e8, 0x00000001, 0x00050036, + 0x00000002, 0x00000004, 0x00000000, 0x00000003, 0x000200f8, 0x00000005, 0x0004003b, 0x0000000b, 0x000000eb, 0x00000007, + 0x0004003b, 0x0000000b, 0x000000ed, 0x00000007, 0x0004003b, 0x0000000b, 0x000000f0, 0x00000007, 0x00050041, 0x000000e4, + 0x000000e5, 0x000000e2, 0x00000041, 0x0003003e, 0x000000e5, 0x000000e3, 0x0004003d, 0x00000024, 0x000000e9, 0x000000e8, + 0x0004007c, 0x0000000a, 0x000000ea, 0x000000e9, 0x0003003e, 0x000000eb, 0x000000ea, 0x00060041, 0x00000087, 0x000000ee, + 0x00000086, 0x00000025, 0x00000051, 0x0004003d, 0x0000000a, 0x000000ef, 0x000000ee, 0x0003003e, 0x000000ed, 0x000000ef, + 0x00060041, 0x00000087, 0x000000f1, 0x00000086, 0x00000025, 0x00000025, 0x0004003d, 0x0000000a, 0x000000f2, 0x000000f1, + 0x0003003e, 0x000000f0, 0x000000f2, 0x00070039, 0x00000002, 0x000000f3, 0x0000001d, 0x000000eb, 0x000000ed, 0x000000f0, + 0x000100fd, 0x00010038, 0x00050036, 0x00000006, 0x00000008, 0x00000000, 0x00000007, 0x000200f8, 0x00000009, 0x00060041, + 0x00000026, 0x00000027, 0x00000023, 0x00000025, 0x00000025, 0x0004003d, 0x0000000a, 0x00000028, 0x00000027, 0x00060041, + 0x00000026, 0x0000002f, 0x0000002d, 0x00000025, 0x00000028, 0x000700ea, 0x0000000a, 0x00000032, 0x0000002f, 0x00000030, + 0x00000031, 0x00000030, 0x000500ae, 0x00000006, 0x00000035, 0x00000032, 0x00000034, 0x000200fe, 0x00000035, 0x00010038, + 0x00050036, 0x00000002, 0x00000013, 0x00000000, 0x0000000c, 0x00030037, 0x0000000b, 0x0000000d, 0x00030037, 0x0000000b, + 0x0000000e, 0x00030037, 0x0000000b, 0x0000000f, 0x00030037, 0x0000000b, 0x00000010, 0x00030037, 0x0000000b, 0x00000011, + 0x00030037, 0x0000000b, 0x00000012, 0x000200f8, 0x00000014, 0x00040039, 0x00000006, 0x00000038, 0x00000008, 0x000300f7, + 0x0000003a, 0x00000000, 0x000400fa, 0x00000038, 0x00000039, 0x0000003a, 0x000200f8, 0x00000039, 0x000100fd, 0x000200f8, + 0x0000003a, 0x00050041, 0x00000026, 0x00000042, 0x00000040, 0x00000041, 0x000700ea, 0x0000000a, 0x00000044, 0x00000042, + 0x00000030, 0x00000031, 0x00000043, 0x00050080, 0x0000000a, 0x00000048, 0x00000044, 0x00000043, 0x00050044, 0x0000000a, + 0x00000049, 0x00000040, 0x00000002, 0x0004007c, 0x00000024, 0x0000004a, 0x00000049, 0x0004007c, 0x0000000a, 0x0000004b, + 0x0000004a, 0x000500ac, 0x00000006, 0x0000004c, 0x00000048, 0x0000004b, 0x000300f7, 0x0000004f, 0x00000000, 0x000400fa, + 0x0000004c, 0x0000004e, 0x0000004f, 0x000200f8, 0x0000004e, 0x000100fd, 0x000200f8, 0x0000004f, 0x00060041, 0x00000026, + 0x00000054, 0x00000040, 0x00000051, 0x00000044, 0x0003003e, 0x00000054, 0x00000043, 0x00050080, 0x0000000a, 0x00000057, + 0x00000044, 0x00000056, 0x00060041, 0x00000026, 0x0000005c, 0x0000005b, 0x00000025, 0x00000025, 0x0004003d, 0x0000000a, + 0x0000005d, 0x0000005c, 0x00060041, 0x00000026, 0x0000005e, 0x00000040, 0x00000051, 0x00000057, 0x0003003e, 0x0000005e, + 0x0000005d, 0x00050080, 0x0000000a, 0x00000061, 0x00000044, 0x00000060, 0x00060041, 0x00000026, 0x00000062, 0x00000023, + 0x00000025, 0x00000025, 0x0004003d, 0x0000000a, 0x00000063, 0x00000062, 0x00060041, 0x00000026, 0x00000064, 0x00000040, + 0x00000051, 0x00000061, 0x0003003e, 0x00000064, 0x00000063, 0x00050080, 0x0000000a, 0x00000067, 0x00000044, 0x00000066, + 0x0004003d, 0x0000000a, 0x00000068, 0x0000000d, 0x00060041, 0x00000026, 0x00000069, 0x00000040, 0x00000051, 0x00000067, + 0x0003003e, 0x00000069, 0x00000068, 0x00050080, 0x0000000a, 0x0000006c, 0x00000044, 0x0000006b, 0x0004003d, 0x0000000a, + 0x0000006d, 0x0000000e, 0x00060041, 0x00000026, 0x0000006e, 0x00000040, 0x00000051, 0x0000006c, 0x0003003e, 0x0000006e, + 0x0000006d, 0x00050080, 0x0000000a, 0x00000071, 0x00000044, 0x00000070, 0x0004003d, 0x0000000a, 0x00000072, 0x0000000f, + 0x00060041, 0x00000026, 0x00000073, 0x00000040, 0x00000051, 0x00000071, 0x0003003e, 0x00000073, 0x00000072, 0x00050080, + 0x0000000a, 0x00000076, 0x00000044, 0x00000075, 0x0004003d, 0x0000000a, 0x00000077, 0x00000010, 0x00060041, 0x00000026, + 0x00000078, 0x00000040, 0x00000051, 0x00000076, 0x0003003e, 0x00000078, 0x00000077, 0x00050080, 0x0000000a, 0x0000007b, + 0x00000044, 0x0000007a, 0x0004003d, 0x0000000a, 0x0000007c, 0x00000011, 0x00060041, 0x00000026, 0x0000007d, 0x00000040, + 0x00000051, 0x0000007b, 0x0003003e, 0x0000007d, 0x0000007c, 0x00050080, 0x0000000a, 0x00000080, 0x00000044, 0x0000007f, + 0x0004003d, 0x0000000a, 0x00000081, 0x00000012, 0x00060041, 0x00000026, 0x00000082, 0x00000040, 0x00000051, 0x00000080, + 0x0003003e, 0x00000082, 0x00000081, 0x000100fd, 0x00010038, 0x00050036, 0x0000000a, 0x00000017, 0x00000000, 0x00000015, + 0x00030037, 0x0000000b, 0x00000016, 0x000200f8, 0x00000018, 0x00060041, 0x00000087, 0x00000088, 0x00000086, 0x00000025, + 0x00000041, 0x0004003d, 0x0000000a, 0x00000089, 0x00000088, 0x000500aa, 0x00000006, 0x0000008b, 0x00000089, 0x0000008a, + 0x000300f7, 0x0000008d, 0x00000000, 0x000400fa, 0x0000008b, 0x0000008c, 0x00000096, 0x000200f8, 0x0000008c, 0x0004003d, + 0x0000000a, 0x00000092, 0x00000016, 0x00060041, 0x00000026, 0x00000093, 0x00000091, 0x00000025, 0x00000092, 0x0004003d, + 0x0000000a, 0x00000094, 0x00000093, 0x000200fe, 0x00000094, 0x000200f8, 0x00000096, 0x00060041, 0x00000087, 0x00000097, + 0x00000086, 0x00000025, 0x00000041, 0x0004003d, 0x0000000a, 0x00000098, 0x00000097, 0x000500aa, 0x00000006, 0x00000099, + 0x00000098, 0x00000043, 0x000300f7, 0x0000009b, 0x00000000, 0x000400fa, 0x00000099, 0x0000009a, 0x000000ae, 0x000200f8, + 0x0000009a, 0x0004003d, 0x0000000a, 0x0000009d, 0x00000016, 0x00050086, 0x0000000a, 0x0000009f, 0x0000009d, 0x0000009e, + 0x00060041, 0x00000026, 0x000000a2, 0x00000091, 0x00000025, 0x0000009f, 0x0004003d, 0x0000000a, 0x000000a3, 0x000000a2, + 0x0004003d, 0x0000000a, 0x000000a5, 0x00000016, 0x00050089, 0x0000000a, 0x000000a6, 0x000000a5, 0x0000009e, 0x00050084, + 0x0000000a, 0x000000a7, 0x000000a6, 0x00000043, 0x000500c2, 0x0000000a, 0x000000aa, 0x000000a3, 0x000000a7, 0x000500c7, + 0x0000000a, 0x000000ac, 0x000000aa, 0x000000ab, 0x000200fe, 0x000000ac, 0x000200f8, 0x000000ae, 0x00060041, 0x00000087, + 0x000000af, 0x00000086, 0x00000025, 0x00000041, 0x0004003d, 0x0000000a, 0x000000b0, 0x000000af, 0x000500aa, 0x00000006, + 0x000000b1, 0x000000b0, 0x00000060, 0x000300f7, 0x000000b3, 0x00000000, 0x000400fa, 0x000000b1, 0x000000b2, 0x000000b3, + 0x000200f8, 0x000000b2, 0x0004003d, 0x0000000a, 0x000000b5, 0x00000016, 0x00050086, 0x0000000a, 0x000000b7, 0x000000b5, + 0x000000b6, 0x00060041, 0x00000026, 0x000000ba, 0x00000091, 0x00000025, 0x000000b7, 0x0004003d, 0x0000000a, 0x000000bb, + 0x000000ba, 0x0004003d, 0x0000000a, 0x000000bd, 0x00000016, 0x00050089, 0x0000000a, 0x000000be, 0x000000bd, 0x000000b6, + 0x00050084, 0x0000000a, 0x000000bf, 0x000000be, 0x00000060, 0x000500c2, 0x0000000a, 0x000000c2, 0x000000bb, 0x000000bf, + 0x000500c7, 0x0000000a, 0x000000c4, 0x000000c2, 0x000000c3, 0x000200fe, 0x000000c4, 0x000200f8, 0x000000b3, 0x000200f9, + 0x0000009b, 0x000200f8, 0x0000009b, 0x000200f9, 0x0000008d, 0x000200f8, 0x0000008d, 0x000200fe, 0x00000031, 0x00010038, + 0x00050036, 0x00000002, 0x0000001d, 0x00000000, 0x00000019, 0x00030037, 0x0000000b, 0x0000001a, 0x00030037, 0x0000000b, + 0x0000001b, 0x00030037, 0x0000000b, 0x0000001c, 0x000200f8, 0x0000001e, 0x0004003b, 0x0000000b, 0x000000c9, 0x00000007, + 0x0004003b, 0x0000000b, 0x000000d3, 0x00000007, 0x0004003b, 0x0000000b, 0x000000d4, 0x00000007, 0x0004003b, 0x0000000b, + 0x000000d5, 0x00000007, 0x0004003b, 0x0000000b, 0x000000d7, 0x00000007, 0x0004003b, 0x0000000b, 0x000000d9, 0x00000007, + 0x0004003b, 0x0000000b, 0x000000db, 0x00000007, 0x0004003d, 0x0000000a, 0x000000ca, 0x0000001a, 0x0003003e, 0x000000c9, + 0x000000ca, 0x00050039, 0x0000000a, 0x000000cb, 0x00000017, 0x000000c9, 0x0004003d, 0x0000000a, 0x000000cc, 0x0000001b, + 0x00050080, 0x0000000a, 0x000000cd, 0x000000cb, 0x000000cc, 0x0004003d, 0x0000000a, 0x000000cf, 0x0000001c, 0x000500ae, + 0x00000006, 0x000000d0, 0x000000cd, 0x000000cf, 0x000300f7, 0x000000d2, 0x00000000, 0x000400fa, 0x000000d0, 0x000000d1, + 0x000000d2, 0x000200f8, 0x000000d1, 0x0003003e, 0x000000d3, 0x000000b6, 0x0003003e, 0x000000d4, 0x00000066, 0x0004003d, + 0x0000000a, 0x000000d6, 0x0000001a, 0x0003003e, 0x000000d5, 0x000000d6, 0x0004003d, 0x0000000a, 0x000000d8, 0x0000001b, + 0x0003003e, 0x000000d7, 0x000000d8, 0x0003003e, 0x000000d9, 0x000000cd, 0x0003003e, 0x000000db, 0x00000031, 0x000a0039, + 0x00000002, 0x000000dc, 0x00000013, 0x000000d3, 0x000000d4, 0x000000d5, 0x000000d7, 0x000000d9, 0x000000db, 0x000200f9, + 0x000000d2, 0x000200f8, 0x000000d2, 0x000100fd, 0x00010038, +}; diff --git a/layers/vulkan/generated/cmd_validation_draw_indexed_vert.h b/layers/vulkan/generated/cmd_validation_draw_indexed_vert.h new file mode 100644 index 00000000000..8cf45217acf --- /dev/null +++ b/layers/vulkan/generated/cmd_validation_draw_indexed_vert.h @@ -0,0 +1,30 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See generate_spirv.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2021-2024 The Khronos Group Inc. + * Copyright (c) 2021-2024 Valve Corporation + * Copyright (c) 2021-2024 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************/ + +#pragma once + +#include + +// To view SPIR-V, copy contents of array and paste in https://www.khronos.org/spir/visualizer/ +extern const uint32_t cmd_validation_draw_indexed_vert_size; +extern const uint32_t cmd_validation_draw_indexed_vert[]; diff --git a/layers/vulkan/generated/cmd_validation_draw_mesh_indirect_vert.cpp b/layers/vulkan/generated/cmd_validation_draw_mesh_indirect_vert.cpp new file mode 100644 index 00000000000..a2b9fbfcc14 --- /dev/null +++ b/layers/vulkan/generated/cmd_validation_draw_mesh_indirect_vert.cpp @@ -0,0 +1,209 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See generate_spirv.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2021-2024 The Khronos Group Inc. + * Copyright (c) 2021-2024 Valve Corporation + * Copyright (c) 2021-2024 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************/ + +#include "cmd_validation_draw_mesh_indirect_vert.h" + +// To view SPIR-V, copy contents of array and paste in https://www.khronos.org/spir/visualizer/ +[[maybe_unused]] const uint32_t cmd_validation_draw_mesh_indirect_vert_size = 1792; +[[maybe_unused]] const uint32_t cmd_validation_draw_mesh_indirect_vert[1792] = { + 0x07230203, 0x00010000, 0x0008000b, 0x0000010f, 0x00000000, 0x00020011, 0x00000001, 0x0006000b, 0x00000001, 0x4c534c47, + 0x6474732e, 0x3035342e, 0x00000000, 0x0003000e, 0x00000000, 0x00000001, 0x0007000f, 0x00000000, 0x00000004, 0x6e69616d, + 0x00000000, 0x00000090, 0x000000a0, 0x00030003, 0x00000002, 0x000001c2, 0x00070004, 0x415f4c47, 0x675f4252, 0x735f7570, + 0x65646168, 0x6e695f72, 0x00343674, 0x000a0004, 0x475f4c47, 0x4c474f4f, 0x70635f45, 0x74735f70, 0x5f656c79, 0x656e696c, + 0x7269645f, 0x69746365, 0x00006576, 0x00080004, 0x475f4c47, 0x4c474f4f, 0x6e695f45, 0x64756c63, 0x69645f65, 0x74636572, + 0x00657669, 0x00040005, 0x00000004, 0x6e69616d, 0x00000000, 0x00090005, 0x00000008, 0x4378614d, 0x7245646d, 0x73726f72, + 0x6e756f43, 0x61655274, 0x64656863, 0x00000028, 0x000b0005, 0x00000013, 0x61757047, 0x676f4c76, 0x6f727245, 0x75283472, + 0x31753b31, 0x3b31753b, 0x753b3175, 0x31753b31, 0x0000003b, 0x00050005, 0x0000000d, 0x6f727265, 0x72675f72, 0x0070756f, + 0x00060005, 0x0000000e, 0x6f727265, 0x75735f72, 0x6f635f62, 0x00006564, 0x00040005, 0x0000000f, 0x61726170, 0x00305f6d, + 0x00040005, 0x00000010, 0x61726170, 0x00315f6d, 0x00040005, 0x00000011, 0x61726170, 0x00325f6d, 0x00040005, 0x00000012, + 0x61726170, 0x00335f6d, 0x00090005, 0x0000001a, 0x61757047, 0x676f4c76, 0x6f727245, 0x75283272, 0x31753b31, 0x3b31753b, + 0x003b3175, 0x00050005, 0x00000016, 0x6f727265, 0x72675f72, 0x0070756f, 0x00060005, 0x00000017, 0x6f727265, 0x75735f72, + 0x6f635f62, 0x00006564, 0x00040005, 0x00000018, 0x61726170, 0x00305f6d, 0x00040005, 0x00000019, 0x61726170, 0x00315f6d, + 0x00070005, 0x0000001e, 0x6f736552, 0x65637275, 0x65646e49, 0x66754278, 0x00726566, 0x00070006, 0x0000001e, 0x00000000, + 0x6f736572, 0x65637275, 0x646e695f, 0x00007865, 0x00030005, 0x00000020, 0x00000000, 0x00080005, 0x00000028, 0x45646d43, + 0x726f7272, 0x756f4373, 0x7542746e, 0x72656666, 0x00000000, 0x00080006, 0x00000028, 0x00000000, 0x5f646d63, 0x6f727265, + 0x635f7372, 0x746e756f, 0x00000000, 0x00030005, 0x0000002a, 0x00000000, 0x00050005, 0x0000003b, 0x6f727245, 0x66754272, + 0x00726566, 0x00050006, 0x0000003b, 0x00000000, 0x67616c66, 0x00000073, 0x00070006, 0x0000003b, 0x00000001, 0x6f727265, + 0x635f7372, 0x746e756f, 0x00000000, 0x00070006, 0x0000003b, 0x00000002, 0x6f727265, 0x625f7372, 0x65666675, 0x00000072, + 0x00030005, 0x0000003d, 0x00000000, 0x00070005, 0x00000056, 0x69746341, 0x6e496e6f, 0x42786564, 0x65666675, 0x00000072, + 0x00070006, 0x00000056, 0x00000000, 0x69746361, 0x695f6e6f, 0x7865646e, 0x00000000, 0x00030005, 0x00000058, 0x00000000, + 0x00040005, 0x00000080, 0x61726170, 0x0000006d, 0x00040005, 0x00000082, 0x61726170, 0x0000006d, 0x00040005, 0x00000084, + 0x61726170, 0x0000006d, 0x00040005, 0x00000086, 0x61726170, 0x0000006d, 0x00040005, 0x00000088, 0x61726170, 0x0000006d, + 0x00040005, 0x00000089, 0x61726170, 0x0000006d, 0x00060005, 0x0000008e, 0x505f6c67, 0x65567265, 0x78657472, 0x00000000, + 0x00060006, 0x0000008e, 0x00000000, 0x505f6c67, 0x7469736f, 0x006e6f69, 0x00070006, 0x0000008e, 0x00000001, 0x505f6c67, + 0x746e696f, 0x657a6953, 0x00000000, 0x00070006, 0x0000008e, 0x00000002, 0x435f6c67, 0x4470696c, 0x61747369, 0x0065636e, + 0x00070006, 0x0000008e, 0x00000003, 0x435f6c67, 0x446c6c75, 0x61747369, 0x0065636e, 0x00030005, 0x00000090, 0x00000000, + 0x00070005, 0x00000094, 0x77617244, 0x6873654d, 0x68737550, 0x61746144, 0x00000000, 0x00050006, 0x00000094, 0x00000000, + 0x67616c66, 0x00000073, 0x00090006, 0x00000094, 0x00000001, 0x77617264, 0x646d635f, 0x74735f73, 0x65646972, 0x6f77645f, + 0x00736472, 0x00090006, 0x00000094, 0x00000002, 0x5f78616d, 0x6b726f77, 0x756f7267, 0x6f635f70, 0x5f746e75, 0x00000078, + 0x00090006, 0x00000094, 0x00000003, 0x5f78616d, 0x6b726f77, 0x756f7267, 0x6f635f70, 0x5f746e75, 0x00000079, 0x00090006, + 0x00000094, 0x00000004, 0x5f78616d, 0x6b726f77, 0x756f7267, 0x6f635f70, 0x5f746e75, 0x0000007a, 0x000a0006, 0x00000094, + 0x00000005, 0x5f78616d, 0x6b726f77, 0x756f7267, 0x6f745f70, 0x5f6c6174, 0x6e756f63, 0x00000074, 0x00050005, 0x00000095, + 0x66696e55, 0x496d726f, 0x006f666e, 0x00040006, 0x00000095, 0x00000000, 0x00006370, 0x00030005, 0x00000097, 0x00000000, + 0x00060005, 0x000000a0, 0x565f6c67, 0x65747265, 0x646e4978, 0x00007865, 0x00050005, 0x000000a3, 0x6e756f43, 0x66754274, + 0x00726566, 0x00070006, 0x000000a3, 0x00000000, 0x6e756f63, 0x75625f74, 0x72656666, 0x00000000, 0x00030005, 0x000000a5, + 0x00000000, 0x00050005, 0x000000ae, 0x77617244, 0x66667542, 0x00007265, 0x00060006, 0x000000ae, 0x00000000, 0x77617264, + 0x6675625f, 0x00726566, 0x00030005, 0x000000b0, 0x00000000, 0x00040005, 0x000000d5, 0x61726170, 0x0000006d, 0x00040005, + 0x000000d6, 0x61726170, 0x0000006d, 0x00040005, 0x000000d7, 0x61726170, 0x0000006d, 0x00040005, 0x000000d9, 0x61726170, + 0x0000006d, 0x00040005, 0x000000e5, 0x61726170, 0x0000006d, 0x00040005, 0x000000e6, 0x61726170, 0x0000006d, 0x00040005, + 0x000000e7, 0x61726170, 0x0000006d, 0x00040005, 0x000000e9, 0x61726170, 0x0000006d, 0x00040005, 0x000000f4, 0x61726170, + 0x0000006d, 0x00040005, 0x000000f5, 0x61726170, 0x0000006d, 0x00040005, 0x000000f6, 0x61726170, 0x0000006d, 0x00040005, + 0x000000f8, 0x61726170, 0x0000006d, 0x00040005, 0x00000109, 0x61726170, 0x0000006d, 0x00040005, 0x0000010a, 0x61726170, + 0x0000006d, 0x00040005, 0x0000010b, 0x61726170, 0x0000006d, 0x00040005, 0x0000010d, 0x61726170, 0x0000006d, 0x00040047, + 0x0000001d, 0x00000006, 0x00000004, 0x00030047, 0x0000001e, 0x00000003, 0x00040048, 0x0000001e, 0x00000000, 0x00000018, + 0x00050048, 0x0000001e, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000020, 0x00000021, 0x00000002, 0x00040047, + 0x00000020, 0x00000022, 0x00000000, 0x00040047, 0x00000027, 0x00000006, 0x00000004, 0x00030047, 0x00000028, 0x00000003, + 0x00050048, 0x00000028, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x0000002a, 0x00000021, 0x00000003, 0x00040047, + 0x0000002a, 0x00000022, 0x00000000, 0x00040047, 0x0000003a, 0x00000006, 0x00000004, 0x00030047, 0x0000003b, 0x00000003, + 0x00050048, 0x0000003b, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x0000003b, 0x00000001, 0x00000023, 0x00000004, + 0x00050048, 0x0000003b, 0x00000002, 0x00000023, 0x00000008, 0x00040047, 0x0000003d, 0x00000021, 0x00000000, 0x00040047, + 0x0000003d, 0x00000022, 0x00000000, 0x00040047, 0x00000055, 0x00000006, 0x00000004, 0x00030047, 0x00000056, 0x00000003, + 0x00040048, 0x00000056, 0x00000000, 0x00000018, 0x00050048, 0x00000056, 0x00000000, 0x00000023, 0x00000000, 0x00040047, + 0x00000058, 0x00000021, 0x00000001, 0x00040047, 0x00000058, 0x00000022, 0x00000000, 0x00030047, 0x0000008e, 0x00000002, + 0x00050048, 0x0000008e, 0x00000000, 0x0000000b, 0x00000000, 0x00050048, 0x0000008e, 0x00000001, 0x0000000b, 0x00000001, + 0x00050048, 0x0000008e, 0x00000002, 0x0000000b, 0x00000003, 0x00050048, 0x0000008e, 0x00000003, 0x0000000b, 0x00000004, + 0x00050048, 0x00000094, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x00000094, 0x00000001, 0x00000023, 0x00000004, + 0x00050048, 0x00000094, 0x00000002, 0x00000023, 0x00000008, 0x00050048, 0x00000094, 0x00000003, 0x00000023, 0x0000000c, + 0x00050048, 0x00000094, 0x00000004, 0x00000023, 0x00000010, 0x00050048, 0x00000094, 0x00000005, 0x00000023, 0x00000014, + 0x00030047, 0x00000095, 0x00000002, 0x00050048, 0x00000095, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x000000a0, + 0x0000000b, 0x0000002a, 0x00030047, 0x000000a3, 0x00000003, 0x00040048, 0x000000a3, 0x00000000, 0x00000018, 0x00050048, + 0x000000a3, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x000000a5, 0x00000021, 0x00000001, 0x00040047, 0x000000a5, + 0x00000022, 0x00000001, 0x00040047, 0x000000ad, 0x00000006, 0x00000004, 0x00030047, 0x000000ae, 0x00000003, 0x00040048, + 0x000000ae, 0x00000000, 0x00000018, 0x00050048, 0x000000ae, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x000000b0, + 0x00000021, 0x00000000, 0x00040047, 0x000000b0, 0x00000022, 0x00000001, 0x00020013, 0x00000002, 0x00030021, 0x00000003, + 0x00000002, 0x00020014, 0x00000006, 0x00030021, 0x00000007, 0x00000006, 0x00040015, 0x0000000a, 0x00000020, 0x00000000, + 0x00040020, 0x0000000b, 0x00000007, 0x0000000a, 0x00090021, 0x0000000c, 0x00000002, 0x0000000b, 0x0000000b, 0x0000000b, + 0x0000000b, 0x0000000b, 0x0000000b, 0x00070021, 0x00000015, 0x00000002, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, + 0x0003001d, 0x0000001d, 0x0000000a, 0x0003001e, 0x0000001e, 0x0000001d, 0x00040020, 0x0000001f, 0x00000002, 0x0000001e, + 0x0004003b, 0x0000001f, 0x00000020, 0x00000002, 0x00040015, 0x00000021, 0x00000020, 0x00000001, 0x0004002b, 0x00000021, + 0x00000022, 0x00000000, 0x00040020, 0x00000023, 0x00000002, 0x0000000a, 0x0003001d, 0x00000027, 0x0000000a, 0x0003001e, + 0x00000028, 0x00000027, 0x00040020, 0x00000029, 0x00000002, 0x00000028, 0x0004003b, 0x00000029, 0x0000002a, 0x00000002, + 0x0004002b, 0x0000000a, 0x0000002d, 0x00000001, 0x0004002b, 0x0000000a, 0x0000002e, 0x00000000, 0x0004002b, 0x0000000a, + 0x00000031, 0x00000006, 0x0003001d, 0x0000003a, 0x0000000a, 0x0005001e, 0x0000003b, 0x0000000a, 0x0000000a, 0x0000003a, + 0x00040020, 0x0000003c, 0x00000002, 0x0000003b, 0x0004003b, 0x0000003c, 0x0000003d, 0x00000002, 0x0004002b, 0x00000021, + 0x0000003e, 0x00000001, 0x0004002b, 0x0000000a, 0x00000040, 0x00000010, 0x0004002b, 0x00000021, 0x0000004e, 0x00000002, + 0x0004002b, 0x0000000a, 0x00000053, 0x00000007, 0x0003001d, 0x00000055, 0x0000000a, 0x0003001e, 0x00000056, 0x00000055, + 0x00040020, 0x00000057, 0x00000002, 0x00000056, 0x0004003b, 0x00000057, 0x00000058, 0x00000002, 0x0004002b, 0x0000000a, + 0x0000005d, 0x00000008, 0x0004002b, 0x0000000a, 0x00000063, 0x00000009, 0x0004002b, 0x0000000a, 0x00000068, 0x0000000a, + 0x0004002b, 0x0000000a, 0x0000006d, 0x0000000b, 0x0004002b, 0x0000000a, 0x00000072, 0x0000000c, 0x0004002b, 0x0000000a, + 0x00000077, 0x0000000d, 0x0004002b, 0x0000000a, 0x0000007c, 0x0000000e, 0x00030016, 0x0000008b, 0x00000020, 0x00040017, + 0x0000008c, 0x0000008b, 0x00000004, 0x0004001c, 0x0000008d, 0x0000008b, 0x0000002d, 0x0006001e, 0x0000008e, 0x0000008c, + 0x0000008b, 0x0000008d, 0x0000008d, 0x00040020, 0x0000008f, 0x00000003, 0x0000008e, 0x0004003b, 0x0000008f, 0x00000090, + 0x00000003, 0x0004002b, 0x0000008b, 0x00000091, 0x3f800000, 0x00040020, 0x00000092, 0x00000003, 0x0000008b, 0x0008001e, + 0x00000094, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x0003001e, 0x00000095, 0x00000094, + 0x00040020, 0x00000096, 0x00000009, 0x00000095, 0x0004003b, 0x00000096, 0x00000097, 0x00000009, 0x00040020, 0x00000098, + 0x00000009, 0x0000000a, 0x00040020, 0x0000009f, 0x00000001, 0x00000021, 0x0004003b, 0x0000009f, 0x000000a0, 0x00000001, + 0x0003001e, 0x000000a3, 0x0000000a, 0x00040020, 0x000000a4, 0x00000002, 0x000000a3, 0x0004003b, 0x000000a4, 0x000000a5, + 0x00000002, 0x0003001d, 0x000000ad, 0x0000000a, 0x0003001e, 0x000000ae, 0x000000ad, 0x00040020, 0x000000af, 0x00000002, + 0x000000ae, 0x0004003b, 0x000000af, 0x000000b0, 0x00000002, 0x0004002b, 0x0000000a, 0x000000c8, 0x00000002, 0x0004002b, + 0x0000000a, 0x000000d2, 0x00000004, 0x0004002b, 0x00000021, 0x000000dc, 0x00000003, 0x0004002b, 0x0000000a, 0x000000e2, + 0x00000005, 0x0004002b, 0x00000021, 0x000000ec, 0x00000004, 0x0004002b, 0x00000021, 0x00000101, 0x00000005, 0x00050036, + 0x00000002, 0x00000004, 0x00000000, 0x00000003, 0x000200f8, 0x00000005, 0x0004003b, 0x0000000b, 0x000000d5, 0x00000007, + 0x0004003b, 0x0000000b, 0x000000d6, 0x00000007, 0x0004003b, 0x0000000b, 0x000000d7, 0x00000007, 0x0004003b, 0x0000000b, + 0x000000d9, 0x00000007, 0x0004003b, 0x0000000b, 0x000000e5, 0x00000007, 0x0004003b, 0x0000000b, 0x000000e6, 0x00000007, + 0x0004003b, 0x0000000b, 0x000000e7, 0x00000007, 0x0004003b, 0x0000000b, 0x000000e9, 0x00000007, 0x0004003b, 0x0000000b, + 0x000000f4, 0x00000007, 0x0004003b, 0x0000000b, 0x000000f5, 0x00000007, 0x0004003b, 0x0000000b, 0x000000f6, 0x00000007, + 0x0004003b, 0x0000000b, 0x000000f8, 0x00000007, 0x0004003b, 0x0000000b, 0x00000109, 0x00000007, 0x0004003b, 0x0000000b, + 0x0000010a, 0x00000007, 0x0004003b, 0x0000000b, 0x0000010b, 0x00000007, 0x0004003b, 0x0000000b, 0x0000010d, 0x00000007, + 0x00050041, 0x00000092, 0x00000093, 0x00000090, 0x0000003e, 0x0003003e, 0x00000093, 0x00000091, 0x00060041, 0x00000098, + 0x00000099, 0x00000097, 0x00000022, 0x00000022, 0x0004003d, 0x0000000a, 0x0000009a, 0x00000099, 0x000500c7, 0x0000000a, + 0x0000009b, 0x0000009a, 0x0000002d, 0x000500ab, 0x00000006, 0x0000009c, 0x0000009b, 0x0000002e, 0x000300f7, 0x0000009e, + 0x00000000, 0x000400fa, 0x0000009c, 0x0000009d, 0x0000009e, 0x000200f8, 0x0000009d, 0x0004003d, 0x00000021, 0x000000a1, + 0x000000a0, 0x0004007c, 0x0000000a, 0x000000a2, 0x000000a1, 0x00050041, 0x00000023, 0x000000a6, 0x000000a5, 0x00000022, + 0x0004003d, 0x0000000a, 0x000000a7, 0x000000a6, 0x000500ae, 0x00000006, 0x000000a8, 0x000000a2, 0x000000a7, 0x000300f7, + 0x000000aa, 0x00000000, 0x000400fa, 0x000000a8, 0x000000a9, 0x000000aa, 0x000200f8, 0x000000a9, 0x000100fd, 0x000200f8, + 0x000000aa, 0x000200f9, 0x0000009e, 0x000200f8, 0x0000009e, 0x0004003d, 0x00000021, 0x000000b1, 0x000000a0, 0x0004007c, + 0x0000000a, 0x000000b2, 0x000000b1, 0x00060041, 0x00000098, 0x000000b3, 0x00000097, 0x00000022, 0x0000003e, 0x0004003d, + 0x0000000a, 0x000000b4, 0x000000b3, 0x00050084, 0x0000000a, 0x000000b5, 0x000000b2, 0x000000b4, 0x00060041, 0x00000023, + 0x000000b7, 0x000000b0, 0x00000022, 0x000000b5, 0x0004003d, 0x0000000a, 0x000000b8, 0x000000b7, 0x0004003d, 0x00000021, + 0x000000ba, 0x000000a0, 0x0004007c, 0x0000000a, 0x000000bb, 0x000000ba, 0x00060041, 0x00000098, 0x000000bc, 0x00000097, + 0x00000022, 0x0000003e, 0x0004003d, 0x0000000a, 0x000000bd, 0x000000bc, 0x00050084, 0x0000000a, 0x000000be, 0x000000bb, + 0x000000bd, 0x00050080, 0x0000000a, 0x000000bf, 0x000000be, 0x0000002d, 0x00060041, 0x00000023, 0x000000c0, 0x000000b0, + 0x00000022, 0x000000bf, 0x0004003d, 0x0000000a, 0x000000c1, 0x000000c0, 0x0004003d, 0x00000021, 0x000000c3, 0x000000a0, + 0x0004007c, 0x0000000a, 0x000000c4, 0x000000c3, 0x00060041, 0x00000098, 0x000000c5, 0x00000097, 0x00000022, 0x0000003e, + 0x0004003d, 0x0000000a, 0x000000c6, 0x000000c5, 0x00050084, 0x0000000a, 0x000000c7, 0x000000c4, 0x000000c6, 0x00050080, + 0x0000000a, 0x000000c9, 0x000000c7, 0x000000c8, 0x00060041, 0x00000023, 0x000000ca, 0x000000b0, 0x00000022, 0x000000c9, + 0x0004003d, 0x0000000a, 0x000000cb, 0x000000ca, 0x00060041, 0x00000098, 0x000000cd, 0x00000097, 0x00000022, 0x0000004e, + 0x0004003d, 0x0000000a, 0x000000ce, 0x000000cd, 0x000500ac, 0x00000006, 0x000000cf, 0x000000b8, 0x000000ce, 0x000300f7, + 0x000000d1, 0x00000000, 0x000400fa, 0x000000cf, 0x000000d0, 0x000000d1, 0x000200f8, 0x000000d0, 0x0004003d, 0x00000021, + 0x000000d3, 0x000000a0, 0x0004007c, 0x0000000a, 0x000000d4, 0x000000d3, 0x0003003e, 0x000000d5, 0x000000d2, 0x0003003e, + 0x000000d6, 0x000000d2, 0x0003003e, 0x000000d7, 0x000000b8, 0x0003003e, 0x000000d9, 0x000000d4, 0x00080039, 0x00000002, + 0x000000da, 0x0000001a, 0x000000d5, 0x000000d6, 0x000000d7, 0x000000d9, 0x000200f9, 0x000000d1, 0x000200f8, 0x000000d1, + 0x00060041, 0x00000098, 0x000000dd, 0x00000097, 0x00000022, 0x000000dc, 0x0004003d, 0x0000000a, 0x000000de, 0x000000dd, + 0x000500ac, 0x00000006, 0x000000df, 0x000000c1, 0x000000de, 0x000300f7, 0x000000e1, 0x00000000, 0x000400fa, 0x000000df, + 0x000000e0, 0x000000e1, 0x000200f8, 0x000000e0, 0x0004003d, 0x00000021, 0x000000e3, 0x000000a0, 0x0004007c, 0x0000000a, + 0x000000e4, 0x000000e3, 0x0003003e, 0x000000e5, 0x000000d2, 0x0003003e, 0x000000e6, 0x000000e2, 0x0003003e, 0x000000e7, + 0x000000c1, 0x0003003e, 0x000000e9, 0x000000e4, 0x00080039, 0x00000002, 0x000000ea, 0x0000001a, 0x000000e5, 0x000000e6, + 0x000000e7, 0x000000e9, 0x000200f9, 0x000000e1, 0x000200f8, 0x000000e1, 0x00060041, 0x00000098, 0x000000ed, 0x00000097, + 0x00000022, 0x000000ec, 0x0004003d, 0x0000000a, 0x000000ee, 0x000000ed, 0x000500ac, 0x00000006, 0x000000ef, 0x000000cb, + 0x000000ee, 0x000300f7, 0x000000f1, 0x00000000, 0x000400fa, 0x000000ef, 0x000000f0, 0x000000f1, 0x000200f8, 0x000000f0, + 0x0004003d, 0x00000021, 0x000000f2, 0x000000a0, 0x0004007c, 0x0000000a, 0x000000f3, 0x000000f2, 0x0003003e, 0x000000f4, + 0x000000d2, 0x0003003e, 0x000000f5, 0x00000031, 0x0003003e, 0x000000f6, 0x000000cb, 0x0003003e, 0x000000f8, 0x000000f3, + 0x00080039, 0x00000002, 0x000000f9, 0x0000001a, 0x000000f4, 0x000000f5, 0x000000f6, 0x000000f8, 0x000200f9, 0x000000f1, + 0x000200f8, 0x000000f1, 0x00050084, 0x0000000a, 0x000000fd, 0x000000b8, 0x000000c1, 0x00050084, 0x0000000a, 0x000000ff, + 0x000000fd, 0x000000cb, 0x00060041, 0x00000098, 0x00000102, 0x00000097, 0x00000022, 0x00000101, 0x0004003d, 0x0000000a, + 0x00000103, 0x00000102, 0x000500ac, 0x00000006, 0x00000104, 0x000000ff, 0x00000103, 0x000300f7, 0x00000106, 0x00000000, + 0x000400fa, 0x00000104, 0x00000105, 0x00000106, 0x000200f8, 0x00000105, 0x0004003d, 0x00000021, 0x00000107, 0x000000a0, + 0x0004007c, 0x0000000a, 0x00000108, 0x00000107, 0x0003003e, 0x00000109, 0x000000d2, 0x0003003e, 0x0000010a, 0x00000053, + 0x0003003e, 0x0000010b, 0x000000ff, 0x0003003e, 0x0000010d, 0x00000108, 0x00080039, 0x00000002, 0x0000010e, 0x0000001a, + 0x00000109, 0x0000010a, 0x0000010b, 0x0000010d, 0x000200f9, 0x00000106, 0x000200f8, 0x00000106, 0x000100fd, 0x00010038, + 0x00050036, 0x00000006, 0x00000008, 0x00000000, 0x00000007, 0x000200f8, 0x00000009, 0x00060041, 0x00000023, 0x00000024, + 0x00000020, 0x00000022, 0x00000022, 0x0004003d, 0x0000000a, 0x00000025, 0x00000024, 0x00060041, 0x00000023, 0x0000002c, + 0x0000002a, 0x00000022, 0x00000025, 0x000700ea, 0x0000000a, 0x0000002f, 0x0000002c, 0x0000002d, 0x0000002e, 0x0000002d, + 0x000500ae, 0x00000006, 0x00000032, 0x0000002f, 0x00000031, 0x000200fe, 0x00000032, 0x00010038, 0x00050036, 0x00000002, + 0x00000013, 0x00000000, 0x0000000c, 0x00030037, 0x0000000b, 0x0000000d, 0x00030037, 0x0000000b, 0x0000000e, 0x00030037, + 0x0000000b, 0x0000000f, 0x00030037, 0x0000000b, 0x00000010, 0x00030037, 0x0000000b, 0x00000011, 0x00030037, 0x0000000b, + 0x00000012, 0x000200f8, 0x00000014, 0x00040039, 0x00000006, 0x00000035, 0x00000008, 0x000300f7, 0x00000037, 0x00000000, + 0x000400fa, 0x00000035, 0x00000036, 0x00000037, 0x000200f8, 0x00000036, 0x000100fd, 0x000200f8, 0x00000037, 0x00050041, + 0x00000023, 0x0000003f, 0x0000003d, 0x0000003e, 0x000700ea, 0x0000000a, 0x00000041, 0x0000003f, 0x0000002d, 0x0000002e, + 0x00000040, 0x00050080, 0x0000000a, 0x00000045, 0x00000041, 0x00000040, 0x00050044, 0x0000000a, 0x00000046, 0x0000003d, + 0x00000002, 0x0004007c, 0x00000021, 0x00000047, 0x00000046, 0x0004007c, 0x0000000a, 0x00000048, 0x00000047, 0x000500ac, + 0x00000006, 0x00000049, 0x00000045, 0x00000048, 0x000300f7, 0x0000004c, 0x00000000, 0x000400fa, 0x00000049, 0x0000004b, + 0x0000004c, 0x000200f8, 0x0000004b, 0x000100fd, 0x000200f8, 0x0000004c, 0x00060041, 0x00000023, 0x00000051, 0x0000003d, + 0x0000004e, 0x00000041, 0x0003003e, 0x00000051, 0x00000040, 0x00050080, 0x0000000a, 0x00000054, 0x00000041, 0x00000053, + 0x00060041, 0x00000023, 0x00000059, 0x00000058, 0x00000022, 0x00000022, 0x0004003d, 0x0000000a, 0x0000005a, 0x00000059, + 0x00060041, 0x00000023, 0x0000005b, 0x0000003d, 0x0000004e, 0x00000054, 0x0003003e, 0x0000005b, 0x0000005a, 0x00050080, + 0x0000000a, 0x0000005e, 0x00000041, 0x0000005d, 0x00060041, 0x00000023, 0x0000005f, 0x00000020, 0x00000022, 0x00000022, + 0x0004003d, 0x0000000a, 0x00000060, 0x0000005f, 0x00060041, 0x00000023, 0x00000061, 0x0000003d, 0x0000004e, 0x0000005e, + 0x0003003e, 0x00000061, 0x00000060, 0x00050080, 0x0000000a, 0x00000064, 0x00000041, 0x00000063, 0x0004003d, 0x0000000a, + 0x00000065, 0x0000000d, 0x00060041, 0x00000023, 0x00000066, 0x0000003d, 0x0000004e, 0x00000064, 0x0003003e, 0x00000066, + 0x00000065, 0x00050080, 0x0000000a, 0x00000069, 0x00000041, 0x00000068, 0x0004003d, 0x0000000a, 0x0000006a, 0x0000000e, + 0x00060041, 0x00000023, 0x0000006b, 0x0000003d, 0x0000004e, 0x00000069, 0x0003003e, 0x0000006b, 0x0000006a, 0x00050080, + 0x0000000a, 0x0000006e, 0x00000041, 0x0000006d, 0x0004003d, 0x0000000a, 0x0000006f, 0x0000000f, 0x00060041, 0x00000023, + 0x00000070, 0x0000003d, 0x0000004e, 0x0000006e, 0x0003003e, 0x00000070, 0x0000006f, 0x00050080, 0x0000000a, 0x00000073, + 0x00000041, 0x00000072, 0x0004003d, 0x0000000a, 0x00000074, 0x00000010, 0x00060041, 0x00000023, 0x00000075, 0x0000003d, + 0x0000004e, 0x00000073, 0x0003003e, 0x00000075, 0x00000074, 0x00050080, 0x0000000a, 0x00000078, 0x00000041, 0x00000077, + 0x0004003d, 0x0000000a, 0x00000079, 0x00000011, 0x00060041, 0x00000023, 0x0000007a, 0x0000003d, 0x0000004e, 0x00000078, + 0x0003003e, 0x0000007a, 0x00000079, 0x00050080, 0x0000000a, 0x0000007d, 0x00000041, 0x0000007c, 0x0004003d, 0x0000000a, + 0x0000007e, 0x00000012, 0x00060041, 0x00000023, 0x0000007f, 0x0000003d, 0x0000004e, 0x0000007d, 0x0003003e, 0x0000007f, + 0x0000007e, 0x000100fd, 0x00010038, 0x00050036, 0x00000002, 0x0000001a, 0x00000000, 0x00000015, 0x00030037, 0x0000000b, + 0x00000016, 0x00030037, 0x0000000b, 0x00000017, 0x00030037, 0x0000000b, 0x00000018, 0x00030037, 0x0000000b, 0x00000019, + 0x000200f8, 0x0000001b, 0x0004003b, 0x0000000b, 0x00000080, 0x00000007, 0x0004003b, 0x0000000b, 0x00000082, 0x00000007, + 0x0004003b, 0x0000000b, 0x00000084, 0x00000007, 0x0004003b, 0x0000000b, 0x00000086, 0x00000007, 0x0004003b, 0x0000000b, + 0x00000088, 0x00000007, 0x0004003b, 0x0000000b, 0x00000089, 0x00000007, 0x0004003d, 0x0000000a, 0x00000081, 0x00000016, + 0x0003003e, 0x00000080, 0x00000081, 0x0004003d, 0x0000000a, 0x00000083, 0x00000017, 0x0003003e, 0x00000082, 0x00000083, + 0x0004003d, 0x0000000a, 0x00000085, 0x00000018, 0x0003003e, 0x00000084, 0x00000085, 0x0004003d, 0x0000000a, 0x00000087, + 0x00000019, 0x0003003e, 0x00000086, 0x00000087, 0x0003003e, 0x00000088, 0x0000002e, 0x0003003e, 0x00000089, 0x0000002e, + 0x000a0039, 0x00000002, 0x0000008a, 0x00000013, 0x00000080, 0x00000082, 0x00000084, 0x00000086, 0x00000088, 0x00000089, + 0x000100fd, 0x00010038, +}; diff --git a/layers/vulkan/generated/cmd_validation_draw_mesh_indirect_vert.h b/layers/vulkan/generated/cmd_validation_draw_mesh_indirect_vert.h new file mode 100644 index 00000000000..8cb50ce53cf --- /dev/null +++ b/layers/vulkan/generated/cmd_validation_draw_mesh_indirect_vert.h @@ -0,0 +1,30 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See generate_spirv.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2021-2024 The Khronos Group Inc. + * Copyright (c) 2021-2024 Valve Corporation + * Copyright (c) 2021-2024 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************/ + +#pragma once + +#include + +// To view SPIR-V, copy contents of array and paste in https://www.khronos.org/spir/visualizer/ +extern const uint32_t cmd_validation_draw_mesh_indirect_vert_size; +extern const uint32_t cmd_validation_draw_mesh_indirect_vert[]; diff --git a/layers/vulkan/generated/cmd_validation_draw_vert.cpp b/layers/vulkan/generated/cmd_validation_draw_vert.cpp deleted file mode 100644 index 0d830a398a5..00000000000 --- a/layers/vulkan/generated/cmd_validation_draw_vert.cpp +++ /dev/null @@ -1,243 +0,0 @@ -// *** THIS FILE IS GENERATED - DO NOT EDIT *** -// See generate_spirv.py for modifications - -/*************************************************************************** - * - * Copyright (c) 2021-2024 The Khronos Group Inc. - * Copyright (c) 2021-2024 Valve Corporation - * Copyright (c) 2021-2024 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - ****************************************************************************/ - -#include "cmd_validation_draw_vert.h" - -// To view SPIR-V, copy contents of array and paste in https://www.khronos.org/spir/visualizer/ -[[maybe_unused]] const uint32_t cmd_validation_draw_vert_size = 2139; -[[maybe_unused]] const uint32_t cmd_validation_draw_vert[2139] = { - 0x07230203, 0x00010000, 0x0008000b, 0x00000151, 0x00000000, 0x00020011, 0x00000001, 0x0006000b, 0x00000001, 0x4c534c47, - 0x6474732e, 0x3035342e, 0x00000000, 0x0003000e, 0x00000000, 0x00000001, 0x0006000f, 0x00000000, 0x00000004, 0x6e69616d, - 0x00000000, 0x0000006e, 0x00030003, 0x00000002, 0x000001c2, 0x000a0004, 0x475f4c47, 0x4c474f4f, 0x70635f45, 0x74735f70, - 0x5f656c79, 0x656e696c, 0x7269645f, 0x69746365, 0x00006576, 0x00080004, 0x475f4c47, 0x4c474f4f, 0x6e695f45, 0x64756c63, - 0x69645f65, 0x74636572, 0x00657669, 0x00040005, 0x00000004, 0x6e69616d, 0x00000000, 0x00090005, 0x00000008, 0x4378614d, - 0x7245646d, 0x73726f72, 0x6e756f43, 0x61655274, 0x64656863, 0x00000028, 0x00090005, 0x00000011, 0x61757047, 0x676f4c76, - 0x6f727245, 0x31752872, 0x3b31753b, 0x753b3175, 0x00003b31, 0x00050005, 0x0000000d, 0x6f727265, 0x72675f72, 0x0070756f, - 0x00060005, 0x0000000e, 0x6f727265, 0x75735f72, 0x6f635f62, 0x00006564, 0x00040005, 0x0000000f, 0x61726170, 0x00305f6d, - 0x00040005, 0x00000010, 0x61726170, 0x00315f6d, 0x00070005, 0x00000015, 0x6f736552, 0x65637275, 0x65646e49, 0x66754278, - 0x00726566, 0x00070006, 0x00000015, 0x00000000, 0x6f736572, 0x65637275, 0x646e695f, 0x00007865, 0x00030005, 0x00000017, - 0x00000000, 0x00080005, 0x0000001f, 0x45646d43, 0x726f7272, 0x756f4373, 0x7542746e, 0x72656666, 0x00000000, 0x00080006, - 0x0000001f, 0x00000000, 0x5f646d63, 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, 0x00030005, 0x00000021, 0x00000000, - 0x00050005, 0x00000032, 0x6f727245, 0x66754272, 0x00726566, 0x00050006, 0x00000032, 0x00000000, 0x67616c66, 0x00000073, - 0x00070006, 0x00000032, 0x00000001, 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, 0x00070006, 0x00000032, 0x00000002, - 0x6f727265, 0x625f7372, 0x65666675, 0x00000072, 0x00030005, 0x00000034, 0x00000000, 0x00070005, 0x0000004d, 0x69746341, - 0x6e496e6f, 0x42786564, 0x65666675, 0x00000072, 0x00070006, 0x0000004d, 0x00000000, 0x69746361, 0x695f6e6f, 0x7865646e, - 0x00000000, 0x00030005, 0x0000004f, 0x00000000, 0x00060005, 0x0000006e, 0x565f6c67, 0x65747265, 0x646e4978, 0x00007865, - 0x00050005, 0x00000073, 0x66696e55, 0x496d726f, 0x006f666e, 0x00090006, 0x00000073, 0x00000000, 0x68737570, 0x6e6f635f, - 0x6e617473, 0x6f775f74, 0x305f6472, 0x00000000, 0x00090006, 0x00000073, 0x00000001, 0x68737570, 0x6e6f635f, 0x6e617473, - 0x6f775f74, 0x315f6472, 0x00000000, 0x00090006, 0x00000073, 0x00000002, 0x68737570, 0x6e6f635f, 0x6e617473, 0x6f775f74, - 0x325f6472, 0x00000000, 0x00090006, 0x00000073, 0x00000003, 0x68737570, 0x6e6f635f, 0x6e617473, 0x6f775f74, 0x335f6472, - 0x00000000, 0x00090006, 0x00000073, 0x00000004, 0x68737570, 0x6e6f635f, 0x6e617473, 0x6f775f74, 0x345f6472, 0x00000000, - 0x00090006, 0x00000073, 0x00000005, 0x68737570, 0x6e6f635f, 0x6e617473, 0x6f775f74, 0x355f6472, 0x00000000, 0x00090006, - 0x00000073, 0x00000006, 0x68737570, 0x6e6f635f, 0x6e617473, 0x6f775f74, 0x365f6472, 0x00000000, 0x00090006, 0x00000073, - 0x00000007, 0x68737570, 0x6e6f635f, 0x6e617473, 0x6f775f74, 0x375f6472, 0x00000000, 0x00090006, 0x00000073, 0x00000008, - 0x68737570, 0x6e6f635f, 0x6e617473, 0x6f775f74, 0x385f6472, 0x00000000, 0x00090006, 0x00000073, 0x00000009, 0x68737570, - 0x6e6f635f, 0x6e617473, 0x6f775f74, 0x395f6472, 0x00000000, 0x00090006, 0x00000073, 0x0000000a, 0x68737570, 0x6e6f635f, - 0x6e617473, 0x6f775f74, 0x315f6472, 0x00000030, 0x00030005, 0x00000075, 0x00000000, 0x00050005, 0x00000086, 0x6e756f43, - 0x66754274, 0x00726566, 0x00070006, 0x00000086, 0x00000000, 0x6e756f63, 0x75625f74, 0x72656666, 0x00000000, 0x00030005, - 0x00000088, 0x00000000, 0x00040005, 0x00000095, 0x61726170, 0x0000006d, 0x00040005, 0x00000096, 0x61726170, 0x0000006d, - 0x00040005, 0x00000097, 0x61726170, 0x0000006d, 0x00040005, 0x00000099, 0x61726170, 0x0000006d, 0x00040005, 0x000000a3, - 0x61726170, 0x0000006d, 0x00040005, 0x000000a4, 0x61726170, 0x0000006d, 0x00040005, 0x000000a5, 0x61726170, 0x0000006d, - 0x00040005, 0x000000a7, 0x61726170, 0x0000006d, 0x00050005, 0x000000af, 0x695f6966, 0x7865646e, 0x00000000, 0x00030005, - 0x000000b2, 0x00000069, 0x00050005, 0x000000bd, 0x77617244, 0x66667542, 0x00007265, 0x00070006, 0x000000bd, 0x00000000, - 0x77617264, 0x75625f73, 0x72656666, 0x00000000, 0x00030005, 0x000000bf, 0x00000000, 0x00040005, 0x000000c6, 0x61726170, - 0x0000006d, 0x00040005, 0x000000c7, 0x61726170, 0x0000006d, 0x00040005, 0x000000c8, 0x61726170, 0x0000006d, 0x00040005, - 0x000000ca, 0x61726170, 0x0000006d, 0x00070005, 0x000000e0, 0x77617264, 0x6675625f, 0x5f726566, 0x65646e69, 0x00000078, - 0x00080005, 0x000000ed, 0x68737570, 0x6e6f635f, 0x6e617473, 0x6f775f74, 0x315f6472, 0x00000000, 0x00030005, 0x000000f6, - 0x00000069, 0x00040005, 0x00000114, 0x61726170, 0x0000006d, 0x00040005, 0x00000115, 0x61726170, 0x0000006d, 0x00040005, - 0x00000116, 0x61726170, 0x0000006d, 0x00040005, 0x00000118, 0x61726170, 0x0000006d, 0x00040005, 0x00000123, 0x61726170, - 0x0000006d, 0x00040005, 0x00000124, 0x61726170, 0x0000006d, 0x00040005, 0x00000125, 0x61726170, 0x0000006d, 0x00040005, - 0x00000127, 0x61726170, 0x0000006d, 0x00040005, 0x00000131, 0x61726170, 0x0000006d, 0x00040005, 0x00000132, 0x61726170, - 0x0000006d, 0x00040005, 0x00000133, 0x61726170, 0x0000006d, 0x00040005, 0x00000135, 0x61726170, 0x0000006d, 0x00040005, - 0x00000145, 0x61726170, 0x0000006d, 0x00040005, 0x00000146, 0x61726170, 0x0000006d, 0x00040005, 0x00000147, 0x61726170, - 0x0000006d, 0x00040005, 0x00000149, 0x61726170, 0x0000006d, 0x00040047, 0x00000014, 0x00000006, 0x00000004, 0x00030047, - 0x00000015, 0x00000003, 0x00050048, 0x00000015, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000017, 0x00000021, - 0x00000002, 0x00040047, 0x00000017, 0x00000022, 0x00000000, 0x00040047, 0x0000001e, 0x00000006, 0x00000004, 0x00030047, - 0x0000001f, 0x00000003, 0x00050048, 0x0000001f, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000021, 0x00000021, - 0x00000003, 0x00040047, 0x00000021, 0x00000022, 0x00000000, 0x00040047, 0x00000031, 0x00000006, 0x00000004, 0x00030047, - 0x00000032, 0x00000003, 0x00050048, 0x00000032, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x00000032, 0x00000001, - 0x00000023, 0x00000004, 0x00050048, 0x00000032, 0x00000002, 0x00000023, 0x00000008, 0x00040047, 0x00000034, 0x00000021, - 0x00000000, 0x00040047, 0x00000034, 0x00000022, 0x00000000, 0x00040047, 0x0000004c, 0x00000006, 0x00000004, 0x00030047, - 0x0000004d, 0x00000003, 0x00050048, 0x0000004d, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x0000004f, 0x00000021, - 0x00000001, 0x00040047, 0x0000004f, 0x00000022, 0x00000000, 0x00040047, 0x0000006e, 0x0000000b, 0x0000002a, 0x00030047, - 0x00000073, 0x00000002, 0x00050048, 0x00000073, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x00000073, 0x00000001, - 0x00000023, 0x00000004, 0x00050048, 0x00000073, 0x00000002, 0x00000023, 0x00000008, 0x00050048, 0x00000073, 0x00000003, - 0x00000023, 0x0000000c, 0x00050048, 0x00000073, 0x00000004, 0x00000023, 0x00000010, 0x00050048, 0x00000073, 0x00000005, - 0x00000023, 0x00000014, 0x00050048, 0x00000073, 0x00000006, 0x00000023, 0x00000018, 0x00050048, 0x00000073, 0x00000007, - 0x00000023, 0x0000001c, 0x00050048, 0x00000073, 0x00000008, 0x00000023, 0x00000020, 0x00050048, 0x00000073, 0x00000009, - 0x00000023, 0x00000024, 0x00050048, 0x00000073, 0x0000000a, 0x00000023, 0x00000028, 0x00040047, 0x00000085, 0x00000006, - 0x00000004, 0x00030047, 0x00000086, 0x00000003, 0x00050048, 0x00000086, 0x00000000, 0x00000023, 0x00000000, 0x00040047, - 0x00000088, 0x00000021, 0x00000001, 0x00040047, 0x00000088, 0x00000022, 0x00000001, 0x00040047, 0x000000bc, 0x00000006, - 0x00000004, 0x00030047, 0x000000bd, 0x00000003, 0x00050048, 0x000000bd, 0x00000000, 0x00000023, 0x00000000, 0x00040047, - 0x000000bf, 0x00000021, 0x00000000, 0x00040047, 0x000000bf, 0x00000022, 0x00000001, 0x00020013, 0x00000002, 0x00030021, - 0x00000003, 0x00000002, 0x00020014, 0x00000006, 0x00030021, 0x00000007, 0x00000006, 0x00040015, 0x0000000a, 0x00000020, - 0x00000000, 0x00040020, 0x0000000b, 0x00000007, 0x0000000a, 0x00070021, 0x0000000c, 0x00000002, 0x0000000b, 0x0000000b, - 0x0000000b, 0x0000000b, 0x0003001d, 0x00000014, 0x0000000a, 0x0003001e, 0x00000015, 0x00000014, 0x00040020, 0x00000016, - 0x00000002, 0x00000015, 0x0004003b, 0x00000016, 0x00000017, 0x00000002, 0x00040015, 0x00000018, 0x00000020, 0x00000001, - 0x0004002b, 0x00000018, 0x00000019, 0x00000000, 0x00040020, 0x0000001a, 0x00000002, 0x0000000a, 0x0003001d, 0x0000001e, - 0x0000000a, 0x0003001e, 0x0000001f, 0x0000001e, 0x00040020, 0x00000020, 0x00000002, 0x0000001f, 0x0004003b, 0x00000020, - 0x00000021, 0x00000002, 0x0004002b, 0x0000000a, 0x00000024, 0x00000001, 0x0004002b, 0x0000000a, 0x00000025, 0x00000000, - 0x0004002b, 0x0000000a, 0x00000028, 0x00000006, 0x0003001d, 0x00000031, 0x0000000a, 0x0005001e, 0x00000032, 0x0000000a, - 0x0000000a, 0x00000031, 0x00040020, 0x00000033, 0x00000002, 0x00000032, 0x0004003b, 0x00000033, 0x00000034, 0x00000002, - 0x0004002b, 0x00000018, 0x00000035, 0x00000001, 0x0004002b, 0x0000000a, 0x00000037, 0x00000010, 0x0004002b, 0x00000018, - 0x00000045, 0x00000002, 0x0004002b, 0x0000000a, 0x0000004a, 0x00000007, 0x0003001d, 0x0000004c, 0x0000000a, 0x0003001e, - 0x0000004d, 0x0000004c, 0x00040020, 0x0000004e, 0x00000002, 0x0000004d, 0x0004003b, 0x0000004e, 0x0000004f, 0x00000002, - 0x0004002b, 0x0000000a, 0x00000054, 0x00000008, 0x0004002b, 0x0000000a, 0x0000005a, 0x00000009, 0x0004002b, 0x0000000a, - 0x0000005f, 0x0000000a, 0x0004002b, 0x0000000a, 0x00000064, 0x0000000b, 0x0004002b, 0x0000000a, 0x00000069, 0x0000000c, - 0x00040020, 0x0000006d, 0x00000001, 0x00000018, 0x0004003b, 0x0000006d, 0x0000006e, 0x00000001, 0x000d001e, 0x00000073, - 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, 0x0000000a, - 0x0000000a, 0x00040020, 0x00000074, 0x00000009, 0x00000073, 0x0004003b, 0x00000074, 0x00000075, 0x00000009, 0x00040020, - 0x00000076, 0x00000009, 0x0000000a, 0x0004002b, 0x0000000a, 0x0000007f, 0x00000003, 0x0003001d, 0x00000085, 0x0000000a, - 0x0003001e, 0x00000086, 0x00000085, 0x00040020, 0x00000087, 0x00000002, 0x00000086, 0x0004003b, 0x00000087, 0x00000088, - 0x00000002, 0x0004002b, 0x00000018, 0x00000089, 0x00000003, 0x0004002b, 0x0000000a, 0x00000094, 0x00000004, 0x0004002b, - 0x0000000a, 0x000000a2, 0x00000002, 0x0003001d, 0x000000bc, 0x0000000a, 0x0003001e, 0x000000bd, 0x000000bc, 0x00040020, - 0x000000be, 0x00000002, 0x000000bd, 0x0004003b, 0x000000be, 0x000000bf, 0x00000002, 0x0004002b, 0x00000018, 0x000000e1, - 0x00000004, 0x0004002b, 0x00000018, 0x000000e5, 0x00000006, 0x0004002b, 0x00000018, 0x000000f3, 0x00000005, 0x0004002b, - 0x00000018, 0x0000010e, 0x00000007, 0x0004002b, 0x00000018, 0x0000011c, 0x00000008, 0x0004002b, 0x0000000a, 0x00000122, - 0x00000005, 0x0004002b, 0x00000018, 0x0000012b, 0x00000009, 0x0004002b, 0x00000018, 0x0000013f, 0x0000000a, 0x00050036, - 0x00000002, 0x00000004, 0x00000000, 0x00000003, 0x000200f8, 0x00000005, 0x0004003b, 0x0000000b, 0x00000095, 0x00000007, - 0x0004003b, 0x0000000b, 0x00000096, 0x00000007, 0x0004003b, 0x0000000b, 0x00000097, 0x00000007, 0x0004003b, 0x0000000b, - 0x00000099, 0x00000007, 0x0004003b, 0x0000000b, 0x000000a3, 0x00000007, 0x0004003b, 0x0000000b, 0x000000a4, 0x00000007, - 0x0004003b, 0x0000000b, 0x000000a5, 0x00000007, 0x0004003b, 0x0000000b, 0x000000a7, 0x00000007, 0x0004003b, 0x0000000b, - 0x000000af, 0x00000007, 0x0004003b, 0x0000000b, 0x000000b2, 0x00000007, 0x0004003b, 0x0000000b, 0x000000c6, 0x00000007, - 0x0004003b, 0x0000000b, 0x000000c7, 0x00000007, 0x0004003b, 0x0000000b, 0x000000c8, 0x00000007, 0x0004003b, 0x0000000b, - 0x000000ca, 0x00000007, 0x0004003b, 0x0000000b, 0x000000e0, 0x00000007, 0x0004003b, 0x0000000b, 0x000000ed, 0x00000007, - 0x0004003b, 0x0000000b, 0x000000f6, 0x00000007, 0x0004003b, 0x0000000b, 0x00000114, 0x00000007, 0x0004003b, 0x0000000b, - 0x00000115, 0x00000007, 0x0004003b, 0x0000000b, 0x00000116, 0x00000007, 0x0004003b, 0x0000000b, 0x00000118, 0x00000007, - 0x0004003b, 0x0000000b, 0x00000123, 0x00000007, 0x0004003b, 0x0000000b, 0x00000124, 0x00000007, 0x0004003b, 0x0000000b, - 0x00000125, 0x00000007, 0x0004003b, 0x0000000b, 0x00000127, 0x00000007, 0x0004003b, 0x0000000b, 0x00000131, 0x00000007, - 0x0004003b, 0x0000000b, 0x00000132, 0x00000007, 0x0004003b, 0x0000000b, 0x00000133, 0x00000007, 0x0004003b, 0x0000000b, - 0x00000135, 0x00000007, 0x0004003b, 0x0000000b, 0x00000145, 0x00000007, 0x0004003b, 0x0000000b, 0x00000146, 0x00000007, - 0x0004003b, 0x0000000b, 0x00000147, 0x00000007, 0x0004003b, 0x0000000b, 0x00000149, 0x00000007, 0x0004003d, 0x00000018, - 0x0000006f, 0x0000006e, 0x000500aa, 0x00000006, 0x00000070, 0x0000006f, 0x00000019, 0x000300f7, 0x00000072, 0x00000000, - 0x000400fa, 0x00000070, 0x00000071, 0x00000072, 0x000200f8, 0x00000071, 0x00050041, 0x00000076, 0x00000077, 0x00000075, - 0x00000019, 0x0004003d, 0x0000000a, 0x00000078, 0x00000077, 0x000500aa, 0x00000006, 0x00000079, 0x00000078, 0x00000024, - 0x000400a8, 0x00000006, 0x0000007a, 0x00000079, 0x000300f7, 0x0000007c, 0x00000000, 0x000400fa, 0x0000007a, 0x0000007b, - 0x0000007c, 0x000200f8, 0x0000007b, 0x00050041, 0x00000076, 0x0000007d, 0x00000075, 0x00000019, 0x0004003d, 0x0000000a, - 0x0000007e, 0x0000007d, 0x000500aa, 0x00000006, 0x00000080, 0x0000007e, 0x0000007f, 0x000200f9, 0x0000007c, 0x000200f8, - 0x0000007c, 0x000700f5, 0x00000006, 0x00000081, 0x00000079, 0x00000071, 0x00000080, 0x0000007b, 0x000300f7, 0x00000083, - 0x00000000, 0x000400fa, 0x00000081, 0x00000082, 0x000000a9, 0x000200f8, 0x00000082, 0x00050041, 0x00000076, 0x0000008a, - 0x00000075, 0x00000089, 0x0004003d, 0x0000000a, 0x0000008b, 0x0000008a, 0x00060041, 0x0000001a, 0x0000008c, 0x00000088, - 0x00000019, 0x0000008b, 0x0004003d, 0x0000000a, 0x0000008d, 0x0000008c, 0x00050041, 0x00000076, 0x0000008f, 0x00000075, - 0x00000045, 0x0004003d, 0x0000000a, 0x00000090, 0x0000008f, 0x000500ac, 0x00000006, 0x00000091, 0x0000008d, 0x00000090, - 0x000300f7, 0x00000093, 0x00000000, 0x000400fa, 0x00000091, 0x00000092, 0x0000009b, 0x000200f8, 0x00000092, 0x0003003e, - 0x00000095, 0x00000094, 0x0003003e, 0x00000096, 0x00000024, 0x0003003e, 0x00000097, 0x0000008d, 0x0003003e, 0x00000099, - 0x00000025, 0x00080039, 0x00000002, 0x0000009a, 0x00000011, 0x00000095, 0x00000096, 0x00000097, 0x00000099, 0x000200f9, - 0x00000093, 0x000200f8, 0x0000009b, 0x00050041, 0x00000076, 0x0000009d, 0x00000075, 0x00000035, 0x0004003d, 0x0000000a, - 0x0000009e, 0x0000009d, 0x000500ac, 0x00000006, 0x0000009f, 0x0000008d, 0x0000009e, 0x000300f7, 0x000000a1, 0x00000000, - 0x000400fa, 0x0000009f, 0x000000a0, 0x000000a1, 0x000200f8, 0x000000a0, 0x0003003e, 0x000000a3, 0x00000094, 0x0003003e, - 0x000000a4, 0x000000a2, 0x0003003e, 0x000000a5, 0x0000008d, 0x0003003e, 0x000000a7, 0x00000025, 0x00080039, 0x00000002, - 0x000000a8, 0x00000011, 0x000000a3, 0x000000a4, 0x000000a5, 0x000000a7, 0x000200f9, 0x000000a1, 0x000200f8, 0x000000a1, - 0x000200f9, 0x00000093, 0x000200f8, 0x00000093, 0x000200f9, 0x00000083, 0x000200f8, 0x000000a9, 0x00050041, 0x00000076, - 0x000000aa, 0x00000075, 0x00000019, 0x0004003d, 0x0000000a, 0x000000ab, 0x000000aa, 0x000500aa, 0x00000006, 0x000000ac, - 0x000000ab, 0x000000a2, 0x000300f7, 0x000000ae, 0x00000000, 0x000400fa, 0x000000ac, 0x000000ad, 0x000000ae, 0x000200f8, - 0x000000ad, 0x00050041, 0x00000076, 0x000000b0, 0x00000075, 0x00000045, 0x0004003d, 0x0000000a, 0x000000b1, 0x000000b0, - 0x0003003e, 0x000000af, 0x000000b1, 0x0003003e, 0x000000b2, 0x00000025, 0x000200f9, 0x000000b3, 0x000200f8, 0x000000b3, - 0x000400f6, 0x000000b5, 0x000000b6, 0x00000000, 0x000200f9, 0x000000b7, 0x000200f8, 0x000000b7, 0x0004003d, 0x0000000a, - 0x000000b8, 0x000000b2, 0x00050041, 0x00000076, 0x000000b9, 0x00000075, 0x00000035, 0x0004003d, 0x0000000a, 0x000000ba, - 0x000000b9, 0x000500b0, 0x00000006, 0x000000bb, 0x000000b8, 0x000000ba, 0x000400fa, 0x000000bb, 0x000000b4, 0x000000b5, - 0x000200f8, 0x000000b4, 0x0004003d, 0x0000000a, 0x000000c0, 0x000000af, 0x00060041, 0x0000001a, 0x000000c1, 0x000000bf, - 0x00000019, 0x000000c0, 0x0004003d, 0x0000000a, 0x000000c2, 0x000000c1, 0x000500ab, 0x00000006, 0x000000c3, 0x000000c2, - 0x00000025, 0x000300f7, 0x000000c5, 0x00000000, 0x000400fa, 0x000000c3, 0x000000c4, 0x000000c5, 0x000200f8, 0x000000c4, - 0x0003003e, 0x000000c6, 0x00000094, 0x0003003e, 0x000000c7, 0x0000007f, 0x0004003d, 0x0000000a, 0x000000c9, 0x000000b2, - 0x0003003e, 0x000000c8, 0x000000c9, 0x0003003e, 0x000000ca, 0x000000c9, 0x00080039, 0x00000002, 0x000000cc, 0x00000011, - 0x000000c6, 0x000000c7, 0x000000c8, 0x000000ca, 0x000200f9, 0x000000b5, 0x000200f8, 0x000000c5, 0x00050041, 0x00000076, - 0x000000ce, 0x00000075, 0x00000089, 0x0004003d, 0x0000000a, 0x000000cf, 0x000000ce, 0x0004003d, 0x0000000a, 0x000000d0, - 0x000000af, 0x00050080, 0x0000000a, 0x000000d1, 0x000000d0, 0x000000cf, 0x0003003e, 0x000000af, 0x000000d1, 0x000200f9, - 0x000000b6, 0x000200f8, 0x000000b6, 0x0004003d, 0x0000000a, 0x000000d2, 0x000000b2, 0x00050080, 0x0000000a, 0x000000d3, - 0x000000d2, 0x00000035, 0x0003003e, 0x000000b2, 0x000000d3, 0x000200f9, 0x000000b3, 0x000200f8, 0x000000b5, 0x000200f9, - 0x000000ae, 0x000200f8, 0x000000ae, 0x000200f9, 0x00000083, 0x000200f8, 0x00000083, 0x00050041, 0x00000076, 0x000000d4, - 0x00000075, 0x00000019, 0x0004003d, 0x0000000a, 0x000000d5, 0x000000d4, 0x000500aa, 0x00000006, 0x000000d6, 0x000000d5, - 0x0000007f, 0x000400a8, 0x00000006, 0x000000d7, 0x000000d6, 0x000300f7, 0x000000d9, 0x00000000, 0x000400fa, 0x000000d7, - 0x000000d8, 0x000000d9, 0x000200f8, 0x000000d8, 0x00050041, 0x00000076, 0x000000da, 0x00000075, 0x00000019, 0x0004003d, - 0x0000000a, 0x000000db, 0x000000da, 0x000500aa, 0x00000006, 0x000000dc, 0x000000db, 0x00000094, 0x000200f9, 0x000000d9, - 0x000200f8, 0x000000d9, 0x000700f5, 0x00000006, 0x000000dd, 0x000000d6, 0x00000083, 0x000000dc, 0x000000d8, 0x000300f7, - 0x000000df, 0x00000000, 0x000400fa, 0x000000dd, 0x000000de, 0x000000df, 0x000200f8, 0x000000de, 0x00050041, 0x00000076, - 0x000000e2, 0x00000075, 0x000000e1, 0x0004003d, 0x0000000a, 0x000000e3, 0x000000e2, 0x0003003e, 0x000000e0, 0x000000e3, - 0x00050041, 0x00000076, 0x000000e6, 0x00000075, 0x000000e5, 0x0004003d, 0x0000000a, 0x000000e7, 0x000000e6, 0x00050041, - 0x00000076, 0x000000e8, 0x00000075, 0x00000019, 0x0004003d, 0x0000000a, 0x000000e9, 0x000000e8, 0x000500aa, 0x00000006, - 0x000000ea, 0x000000e9, 0x0000007f, 0x000300f7, 0x000000ec, 0x00000000, 0x000400fa, 0x000000ea, 0x000000eb, 0x000000f2, - 0x000200f8, 0x000000eb, 0x00050041, 0x00000076, 0x000000ee, 0x00000075, 0x00000089, 0x0004003d, 0x0000000a, 0x000000ef, - 0x000000ee, 0x00060041, 0x0000001a, 0x000000f0, 0x00000088, 0x00000019, 0x000000ef, 0x0004003d, 0x0000000a, 0x000000f1, - 0x000000f0, 0x0003003e, 0x000000ed, 0x000000f1, 0x000200f9, 0x000000ec, 0x000200f8, 0x000000f2, 0x00050041, 0x00000076, - 0x000000f4, 0x00000075, 0x000000f3, 0x0004003d, 0x0000000a, 0x000000f5, 0x000000f4, 0x0003003e, 0x000000ed, 0x000000f5, - 0x000200f9, 0x000000ec, 0x000200f8, 0x000000ec, 0x0003003e, 0x000000f6, 0x00000025, 0x000200f9, 0x000000f7, 0x000200f8, - 0x000000f7, 0x000400f6, 0x000000f9, 0x000000fa, 0x00000000, 0x000200f9, 0x000000fb, 0x000200f8, 0x000000fb, 0x0004003d, - 0x0000000a, 0x000000fc, 0x000000f6, 0x0004003d, 0x0000000a, 0x000000fd, 0x000000ed, 0x000500b0, 0x00000006, 0x000000fe, - 0x000000fc, 0x000000fd, 0x000400fa, 0x000000fe, 0x000000f8, 0x000000f9, 0x000200f8, 0x000000f8, 0x0004003d, 0x0000000a, - 0x00000100, 0x000000e0, 0x00060041, 0x0000001a, 0x00000101, 0x000000bf, 0x00000019, 0x00000100, 0x0004003d, 0x0000000a, - 0x00000102, 0x00000101, 0x00050080, 0x0000000a, 0x00000105, 0x00000100, 0x00000024, 0x00060041, 0x0000001a, 0x00000106, - 0x000000bf, 0x00000019, 0x00000105, 0x0004003d, 0x0000000a, 0x00000107, 0x00000106, 0x00050080, 0x0000000a, 0x0000010a, - 0x00000100, 0x000000a2, 0x00060041, 0x0000001a, 0x0000010b, 0x000000bf, 0x00000019, 0x0000010a, 0x0004003d, 0x0000000a, - 0x0000010c, 0x0000010b, 0x00050041, 0x00000076, 0x0000010f, 0x00000075, 0x0000010e, 0x0004003d, 0x0000000a, 0x00000110, - 0x0000010f, 0x000500ac, 0x00000006, 0x00000111, 0x00000102, 0x00000110, 0x000300f7, 0x00000113, 0x00000000, 0x000400fa, - 0x00000111, 0x00000112, 0x00000113, 0x000200f8, 0x00000112, 0x0003003e, 0x00000114, 0x00000094, 0x0003003e, 0x00000115, - 0x00000094, 0x0003003e, 0x00000116, 0x00000102, 0x0004003d, 0x0000000a, 0x00000119, 0x000000f6, 0x0003003e, 0x00000118, - 0x00000119, 0x00080039, 0x00000002, 0x0000011a, 0x00000011, 0x00000114, 0x00000115, 0x00000116, 0x00000118, 0x000200f9, - 0x00000113, 0x000200f8, 0x00000113, 0x00050041, 0x00000076, 0x0000011d, 0x00000075, 0x0000011c, 0x0004003d, 0x0000000a, - 0x0000011e, 0x0000011d, 0x000500ac, 0x00000006, 0x0000011f, 0x00000107, 0x0000011e, 0x000300f7, 0x00000121, 0x00000000, - 0x000400fa, 0x0000011f, 0x00000120, 0x00000121, 0x000200f8, 0x00000120, 0x0003003e, 0x00000123, 0x00000094, 0x0003003e, - 0x00000124, 0x00000122, 0x0003003e, 0x00000125, 0x00000107, 0x0004003d, 0x0000000a, 0x00000128, 0x000000f6, 0x0003003e, - 0x00000127, 0x00000128, 0x00080039, 0x00000002, 0x00000129, 0x00000011, 0x00000123, 0x00000124, 0x00000125, 0x00000127, - 0x000200f9, 0x00000121, 0x000200f8, 0x00000121, 0x00050041, 0x00000076, 0x0000012c, 0x00000075, 0x0000012b, 0x0004003d, - 0x0000000a, 0x0000012d, 0x0000012c, 0x000500ac, 0x00000006, 0x0000012e, 0x0000010c, 0x0000012d, 0x000300f7, 0x00000130, - 0x00000000, 0x000400fa, 0x0000012e, 0x0000012f, 0x00000130, 0x000200f8, 0x0000012f, 0x0003003e, 0x00000131, 0x00000094, - 0x0003003e, 0x00000132, 0x00000028, 0x0003003e, 0x00000133, 0x0000010c, 0x0004003d, 0x0000000a, 0x00000136, 0x000000f6, - 0x0003003e, 0x00000135, 0x00000136, 0x00080039, 0x00000002, 0x00000137, 0x00000011, 0x00000131, 0x00000132, 0x00000133, - 0x00000135, 0x000200f9, 0x00000130, 0x000200f8, 0x00000130, 0x00050084, 0x0000000a, 0x0000013b, 0x00000102, 0x00000107, - 0x00050084, 0x0000000a, 0x0000013d, 0x0000013b, 0x0000010c, 0x00050041, 0x00000076, 0x00000140, 0x00000075, 0x0000013f, - 0x0004003d, 0x0000000a, 0x00000141, 0x00000140, 0x000500ac, 0x00000006, 0x00000142, 0x0000013d, 0x00000141, 0x000300f7, - 0x00000144, 0x00000000, 0x000400fa, 0x00000142, 0x00000143, 0x00000144, 0x000200f8, 0x00000143, 0x0003003e, 0x00000145, - 0x00000094, 0x0003003e, 0x00000146, 0x0000004a, 0x0003003e, 0x00000147, 0x0000013d, 0x0004003d, 0x0000000a, 0x0000014a, - 0x000000f6, 0x0003003e, 0x00000149, 0x0000014a, 0x00080039, 0x00000002, 0x0000014b, 0x00000011, 0x00000145, 0x00000146, - 0x00000147, 0x00000149, 0x000200f9, 0x00000144, 0x000200f8, 0x00000144, 0x0004003d, 0x0000000a, 0x0000014d, 0x000000e0, - 0x00050080, 0x0000000a, 0x0000014e, 0x0000014d, 0x000000e7, 0x0003003e, 0x000000e0, 0x0000014e, 0x000200f9, 0x000000fa, - 0x000200f8, 0x000000fa, 0x0004003d, 0x0000000a, 0x0000014f, 0x000000f6, 0x00050080, 0x0000000a, 0x00000150, 0x0000014f, - 0x00000035, 0x0003003e, 0x000000f6, 0x00000150, 0x000200f9, 0x000000f7, 0x000200f8, 0x000000f9, 0x000200f9, 0x000000df, - 0x000200f8, 0x000000df, 0x000200f9, 0x00000072, 0x000200f8, 0x00000072, 0x000100fd, 0x00010038, 0x00050036, 0x00000006, - 0x00000008, 0x00000000, 0x00000007, 0x000200f8, 0x00000009, 0x00060041, 0x0000001a, 0x0000001b, 0x00000017, 0x00000019, - 0x00000019, 0x0004003d, 0x0000000a, 0x0000001c, 0x0000001b, 0x00060041, 0x0000001a, 0x00000023, 0x00000021, 0x00000019, - 0x0000001c, 0x000700ea, 0x0000000a, 0x00000026, 0x00000023, 0x00000024, 0x00000025, 0x00000024, 0x000500ae, 0x00000006, - 0x00000029, 0x00000026, 0x00000028, 0x000200fe, 0x00000029, 0x00010038, 0x00050036, 0x00000002, 0x00000011, 0x00000000, - 0x0000000c, 0x00030037, 0x0000000b, 0x0000000d, 0x00030037, 0x0000000b, 0x0000000e, 0x00030037, 0x0000000b, 0x0000000f, - 0x00030037, 0x0000000b, 0x00000010, 0x000200f8, 0x00000012, 0x00040039, 0x00000006, 0x0000002c, 0x00000008, 0x000300f7, - 0x0000002e, 0x00000000, 0x000400fa, 0x0000002c, 0x0000002d, 0x0000002e, 0x000200f8, 0x0000002d, 0x000100fd, 0x000200f8, - 0x0000002e, 0x00050041, 0x0000001a, 0x00000036, 0x00000034, 0x00000035, 0x000700ea, 0x0000000a, 0x00000038, 0x00000036, - 0x00000024, 0x00000025, 0x00000037, 0x00050080, 0x0000000a, 0x0000003c, 0x00000038, 0x00000037, 0x00050044, 0x0000000a, - 0x0000003d, 0x00000034, 0x00000002, 0x0004007c, 0x00000018, 0x0000003e, 0x0000003d, 0x0004007c, 0x0000000a, 0x0000003f, - 0x0000003e, 0x000500ac, 0x00000006, 0x00000040, 0x0000003c, 0x0000003f, 0x000300f7, 0x00000043, 0x00000000, 0x000400fa, - 0x00000040, 0x00000042, 0x00000043, 0x000200f8, 0x00000042, 0x000100fd, 0x000200f8, 0x00000043, 0x00060041, 0x0000001a, - 0x00000048, 0x00000034, 0x00000045, 0x00000038, 0x0003003e, 0x00000048, 0x00000037, 0x00050080, 0x0000000a, 0x0000004b, - 0x00000038, 0x0000004a, 0x00060041, 0x0000001a, 0x00000050, 0x0000004f, 0x00000019, 0x00000019, 0x0004003d, 0x0000000a, - 0x00000051, 0x00000050, 0x00060041, 0x0000001a, 0x00000052, 0x00000034, 0x00000045, 0x0000004b, 0x0003003e, 0x00000052, - 0x00000051, 0x00050080, 0x0000000a, 0x00000055, 0x00000038, 0x00000054, 0x00060041, 0x0000001a, 0x00000056, 0x00000017, - 0x00000019, 0x00000019, 0x0004003d, 0x0000000a, 0x00000057, 0x00000056, 0x00060041, 0x0000001a, 0x00000058, 0x00000034, - 0x00000045, 0x00000055, 0x0003003e, 0x00000058, 0x00000057, 0x00050080, 0x0000000a, 0x0000005b, 0x00000038, 0x0000005a, - 0x0004003d, 0x0000000a, 0x0000005c, 0x0000000d, 0x00060041, 0x0000001a, 0x0000005d, 0x00000034, 0x00000045, 0x0000005b, - 0x0003003e, 0x0000005d, 0x0000005c, 0x00050080, 0x0000000a, 0x00000060, 0x00000038, 0x0000005f, 0x0004003d, 0x0000000a, - 0x00000061, 0x0000000e, 0x00060041, 0x0000001a, 0x00000062, 0x00000034, 0x00000045, 0x00000060, 0x0003003e, 0x00000062, - 0x00000061, 0x00050080, 0x0000000a, 0x00000065, 0x00000038, 0x00000064, 0x0004003d, 0x0000000a, 0x00000066, 0x0000000f, - 0x00060041, 0x0000001a, 0x00000067, 0x00000034, 0x00000045, 0x00000065, 0x0003003e, 0x00000067, 0x00000066, 0x00050080, - 0x0000000a, 0x0000006a, 0x00000038, 0x00000069, 0x0004003d, 0x0000000a, 0x0000006b, 0x00000010, 0x00060041, 0x0000001a, - 0x0000006c, 0x00000034, 0x00000045, 0x0000006a, 0x0003003e, 0x0000006c, 0x0000006b, 0x000100fd, 0x00010038, -}; diff --git a/layers/vulkan/generated/cmd_validation_first_instance_vert.cpp b/layers/vulkan/generated/cmd_validation_first_instance_vert.cpp new file mode 100644 index 00000000000..bef22286b4c --- /dev/null +++ b/layers/vulkan/generated/cmd_validation_first_instance_vert.cpp @@ -0,0 +1,169 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See generate_spirv.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2021-2024 The Khronos Group Inc. + * Copyright (c) 2021-2024 Valve Corporation + * Copyright (c) 2021-2024 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************/ + +#include "cmd_validation_first_instance_vert.h" + +// To view SPIR-V, copy contents of array and paste in https://www.khronos.org/spir/visualizer/ +[[maybe_unused]] const uint32_t cmd_validation_first_instance_vert_size = 1392; +[[maybe_unused]] const uint32_t cmd_validation_first_instance_vert[1392] = { + 0x07230203, 0x00010000, 0x0008000b, 0x000000c9, 0x00000000, 0x00020011, 0x00000001, 0x0006000b, 0x00000001, 0x4c534c47, + 0x6474732e, 0x3035342e, 0x00000000, 0x0003000e, 0x00000000, 0x00000001, 0x0007000f, 0x00000000, 0x00000004, 0x6e69616d, + 0x00000000, 0x00000090, 0x000000a0, 0x00030003, 0x00000002, 0x000001c2, 0x00070004, 0x415f4c47, 0x675f4252, 0x735f7570, + 0x65646168, 0x6e695f72, 0x00343674, 0x000a0004, 0x475f4c47, 0x4c474f4f, 0x70635f45, 0x74735f70, 0x5f656c79, 0x656e696c, + 0x7269645f, 0x69746365, 0x00006576, 0x00080004, 0x475f4c47, 0x4c474f4f, 0x6e695f45, 0x64756c63, 0x69645f65, 0x74636572, + 0x00657669, 0x00040005, 0x00000004, 0x6e69616d, 0x00000000, 0x00090005, 0x00000008, 0x4378614d, 0x7245646d, 0x73726f72, + 0x6e756f43, 0x61655274, 0x64656863, 0x00000028, 0x000b0005, 0x00000013, 0x61757047, 0x676f4c76, 0x6f727245, 0x75283472, + 0x31753b31, 0x3b31753b, 0x753b3175, 0x31753b31, 0x0000003b, 0x00050005, 0x0000000d, 0x6f727265, 0x72675f72, 0x0070756f, + 0x00060005, 0x0000000e, 0x6f727265, 0x75735f72, 0x6f635f62, 0x00006564, 0x00040005, 0x0000000f, 0x61726170, 0x00305f6d, + 0x00040005, 0x00000010, 0x61726170, 0x00315f6d, 0x00040005, 0x00000011, 0x61726170, 0x00325f6d, 0x00040005, 0x00000012, + 0x61726170, 0x00335f6d, 0x00090005, 0x0000001a, 0x61757047, 0x676f4c76, 0x6f727245, 0x75283272, 0x31753b31, 0x3b31753b, + 0x003b3175, 0x00050005, 0x00000016, 0x6f727265, 0x72675f72, 0x0070756f, 0x00060005, 0x00000017, 0x6f727265, 0x75735f72, + 0x6f635f62, 0x00006564, 0x00040005, 0x00000018, 0x61726170, 0x00305f6d, 0x00040005, 0x00000019, 0x61726170, 0x00315f6d, + 0x00070005, 0x0000001e, 0x6f736552, 0x65637275, 0x65646e49, 0x66754278, 0x00726566, 0x00070006, 0x0000001e, 0x00000000, + 0x6f736572, 0x65637275, 0x646e695f, 0x00007865, 0x00030005, 0x00000020, 0x00000000, 0x00080005, 0x00000028, 0x45646d43, + 0x726f7272, 0x756f4373, 0x7542746e, 0x72656666, 0x00000000, 0x00080006, 0x00000028, 0x00000000, 0x5f646d63, 0x6f727265, + 0x635f7372, 0x746e756f, 0x00000000, 0x00030005, 0x0000002a, 0x00000000, 0x00050005, 0x0000003b, 0x6f727245, 0x66754272, + 0x00726566, 0x00050006, 0x0000003b, 0x00000000, 0x67616c66, 0x00000073, 0x00070006, 0x0000003b, 0x00000001, 0x6f727265, + 0x635f7372, 0x746e756f, 0x00000000, 0x00070006, 0x0000003b, 0x00000002, 0x6f727265, 0x625f7372, 0x65666675, 0x00000072, + 0x00030005, 0x0000003d, 0x00000000, 0x00070005, 0x00000056, 0x69746341, 0x6e496e6f, 0x42786564, 0x65666675, 0x00000072, + 0x00070006, 0x00000056, 0x00000000, 0x69746361, 0x695f6e6f, 0x7865646e, 0x00000000, 0x00030005, 0x00000058, 0x00000000, + 0x00040005, 0x00000080, 0x61726170, 0x0000006d, 0x00040005, 0x00000082, 0x61726170, 0x0000006d, 0x00040005, 0x00000084, + 0x61726170, 0x0000006d, 0x00040005, 0x00000086, 0x61726170, 0x0000006d, 0x00040005, 0x00000088, 0x61726170, 0x0000006d, + 0x00040005, 0x00000089, 0x61726170, 0x0000006d, 0x00060005, 0x0000008e, 0x505f6c67, 0x65567265, 0x78657472, 0x00000000, + 0x00060006, 0x0000008e, 0x00000000, 0x505f6c67, 0x7469736f, 0x006e6f69, 0x00070006, 0x0000008e, 0x00000001, 0x505f6c67, + 0x746e696f, 0x657a6953, 0x00000000, 0x00070006, 0x0000008e, 0x00000002, 0x435f6c67, 0x4470696c, 0x61747369, 0x0065636e, + 0x00070006, 0x0000008e, 0x00000003, 0x435f6c67, 0x446c6c75, 0x61747369, 0x0065636e, 0x00030005, 0x00000090, 0x00000000, + 0x00080005, 0x00000094, 0x73726946, 0x736e4974, 0x636e6174, 0x73755065, 0x74614468, 0x00000061, 0x00050006, 0x00000094, + 0x00000000, 0x67616c66, 0x00000073, 0x00090006, 0x00000094, 0x00000001, 0x77617264, 0x646d635f, 0x74735f73, 0x65646972, + 0x6f77645f, 0x00736472, 0x000a0006, 0x00000094, 0x00000002, 0x73726966, 0x6e695f74, 0x6e617473, 0x6d5f6563, 0x65626d65, + 0x6f705f72, 0x00000073, 0x00060005, 0x00000095, 0x68737550, 0x736e6f43, 0x746e6174, 0x00000073, 0x00040006, 0x00000095, + 0x00000000, 0x00006370, 0x00030005, 0x00000097, 0x00000000, 0x00060005, 0x000000a0, 0x565f6c67, 0x65747265, 0x646e4978, + 0x00007865, 0x00050005, 0x000000a3, 0x6e756f43, 0x66754274, 0x00726566, 0x00070006, 0x000000a3, 0x00000000, 0x6e756f63, + 0x75625f74, 0x72656666, 0x00000000, 0x00030005, 0x000000a5, 0x00000000, 0x00050005, 0x000000ae, 0x77617244, 0x66667542, + 0x00007265, 0x000a0006, 0x000000ae, 0x00000000, 0x77617264, 0x646e695f, 0x64657865, 0x646e695f, 0x63657269, 0x6d635f74, + 0x00007364, 0x00030005, 0x000000b0, 0x00000000, 0x00040005, 0x000000c3, 0x61726170, 0x0000006d, 0x00040005, 0x000000c4, + 0x61726170, 0x0000006d, 0x00040005, 0x000000c5, 0x61726170, 0x0000006d, 0x00040005, 0x000000c6, 0x61726170, 0x0000006d, + 0x00040047, 0x0000001d, 0x00000006, 0x00000004, 0x00030047, 0x0000001e, 0x00000003, 0x00040048, 0x0000001e, 0x00000000, + 0x00000018, 0x00050048, 0x0000001e, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000020, 0x00000021, 0x00000002, + 0x00040047, 0x00000020, 0x00000022, 0x00000000, 0x00040047, 0x00000027, 0x00000006, 0x00000004, 0x00030047, 0x00000028, + 0x00000003, 0x00050048, 0x00000028, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x0000002a, 0x00000021, 0x00000003, + 0x00040047, 0x0000002a, 0x00000022, 0x00000000, 0x00040047, 0x0000003a, 0x00000006, 0x00000004, 0x00030047, 0x0000003b, + 0x00000003, 0x00050048, 0x0000003b, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x0000003b, 0x00000001, 0x00000023, + 0x00000004, 0x00050048, 0x0000003b, 0x00000002, 0x00000023, 0x00000008, 0x00040047, 0x0000003d, 0x00000021, 0x00000000, + 0x00040047, 0x0000003d, 0x00000022, 0x00000000, 0x00040047, 0x00000055, 0x00000006, 0x00000004, 0x00030047, 0x00000056, + 0x00000003, 0x00040048, 0x00000056, 0x00000000, 0x00000018, 0x00050048, 0x00000056, 0x00000000, 0x00000023, 0x00000000, + 0x00040047, 0x00000058, 0x00000021, 0x00000001, 0x00040047, 0x00000058, 0x00000022, 0x00000000, 0x00030047, 0x0000008e, + 0x00000002, 0x00050048, 0x0000008e, 0x00000000, 0x0000000b, 0x00000000, 0x00050048, 0x0000008e, 0x00000001, 0x0000000b, + 0x00000001, 0x00050048, 0x0000008e, 0x00000002, 0x0000000b, 0x00000003, 0x00050048, 0x0000008e, 0x00000003, 0x0000000b, + 0x00000004, 0x00050048, 0x00000094, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x00000094, 0x00000001, 0x00000023, + 0x00000004, 0x00050048, 0x00000094, 0x00000002, 0x00000023, 0x00000008, 0x00030047, 0x00000095, 0x00000002, 0x00050048, + 0x00000095, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x000000a0, 0x0000000b, 0x0000002a, 0x00030047, 0x000000a3, + 0x00000003, 0x00040048, 0x000000a3, 0x00000000, 0x00000018, 0x00050048, 0x000000a3, 0x00000000, 0x00000023, 0x00000000, + 0x00040047, 0x000000a5, 0x00000021, 0x00000001, 0x00040047, 0x000000a5, 0x00000022, 0x00000001, 0x00040047, 0x000000ad, + 0x00000006, 0x00000004, 0x00030047, 0x000000ae, 0x00000003, 0x00040048, 0x000000ae, 0x00000000, 0x00000018, 0x00050048, + 0x000000ae, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x000000b0, 0x00000021, 0x00000000, 0x00040047, 0x000000b0, + 0x00000022, 0x00000001, 0x00020013, 0x00000002, 0x00030021, 0x00000003, 0x00000002, 0x00020014, 0x00000006, 0x00030021, + 0x00000007, 0x00000006, 0x00040015, 0x0000000a, 0x00000020, 0x00000000, 0x00040020, 0x0000000b, 0x00000007, 0x0000000a, + 0x00090021, 0x0000000c, 0x00000002, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x00070021, + 0x00000015, 0x00000002, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x0003001d, 0x0000001d, 0x0000000a, 0x0003001e, + 0x0000001e, 0x0000001d, 0x00040020, 0x0000001f, 0x00000002, 0x0000001e, 0x0004003b, 0x0000001f, 0x00000020, 0x00000002, + 0x00040015, 0x00000021, 0x00000020, 0x00000001, 0x0004002b, 0x00000021, 0x00000022, 0x00000000, 0x00040020, 0x00000023, + 0x00000002, 0x0000000a, 0x0003001d, 0x00000027, 0x0000000a, 0x0003001e, 0x00000028, 0x00000027, 0x00040020, 0x00000029, + 0x00000002, 0x00000028, 0x0004003b, 0x00000029, 0x0000002a, 0x00000002, 0x0004002b, 0x0000000a, 0x0000002d, 0x00000001, + 0x0004002b, 0x0000000a, 0x0000002e, 0x00000000, 0x0004002b, 0x0000000a, 0x00000031, 0x00000006, 0x0003001d, 0x0000003a, + 0x0000000a, 0x0005001e, 0x0000003b, 0x0000000a, 0x0000000a, 0x0000003a, 0x00040020, 0x0000003c, 0x00000002, 0x0000003b, + 0x0004003b, 0x0000003c, 0x0000003d, 0x00000002, 0x0004002b, 0x00000021, 0x0000003e, 0x00000001, 0x0004002b, 0x0000000a, + 0x00000040, 0x00000010, 0x0004002b, 0x00000021, 0x0000004e, 0x00000002, 0x0004002b, 0x0000000a, 0x00000053, 0x00000007, + 0x0003001d, 0x00000055, 0x0000000a, 0x0003001e, 0x00000056, 0x00000055, 0x00040020, 0x00000057, 0x00000002, 0x00000056, + 0x0004003b, 0x00000057, 0x00000058, 0x00000002, 0x0004002b, 0x0000000a, 0x0000005d, 0x00000008, 0x0004002b, 0x0000000a, + 0x00000063, 0x00000009, 0x0004002b, 0x0000000a, 0x00000068, 0x0000000a, 0x0004002b, 0x0000000a, 0x0000006d, 0x0000000b, + 0x0004002b, 0x0000000a, 0x00000072, 0x0000000c, 0x0004002b, 0x0000000a, 0x00000077, 0x0000000d, 0x0004002b, 0x0000000a, + 0x0000007c, 0x0000000e, 0x00030016, 0x0000008b, 0x00000020, 0x00040017, 0x0000008c, 0x0000008b, 0x00000004, 0x0004001c, + 0x0000008d, 0x0000008b, 0x0000002d, 0x0006001e, 0x0000008e, 0x0000008c, 0x0000008b, 0x0000008d, 0x0000008d, 0x00040020, + 0x0000008f, 0x00000003, 0x0000008e, 0x0004003b, 0x0000008f, 0x00000090, 0x00000003, 0x0004002b, 0x0000008b, 0x00000091, + 0x3f800000, 0x00040020, 0x00000092, 0x00000003, 0x0000008b, 0x0005001e, 0x00000094, 0x0000000a, 0x0000000a, 0x0000000a, + 0x0003001e, 0x00000095, 0x00000094, 0x00040020, 0x00000096, 0x00000009, 0x00000095, 0x0004003b, 0x00000096, 0x00000097, + 0x00000009, 0x00040020, 0x00000098, 0x00000009, 0x0000000a, 0x00040020, 0x0000009f, 0x00000001, 0x00000021, 0x0004003b, + 0x0000009f, 0x000000a0, 0x00000001, 0x0003001e, 0x000000a3, 0x0000000a, 0x00040020, 0x000000a4, 0x00000002, 0x000000a3, + 0x0004003b, 0x000000a4, 0x000000a5, 0x00000002, 0x0003001d, 0x000000ad, 0x0000000a, 0x0003001e, 0x000000ae, 0x000000ad, + 0x00040020, 0x000000af, 0x00000002, 0x000000ae, 0x0004003b, 0x000000af, 0x000000b0, 0x00000002, 0x0004002b, 0x0000000a, + 0x000000bf, 0x00000004, 0x0004002b, 0x0000000a, 0x000000c0, 0x00000003, 0x00050036, 0x00000002, 0x00000004, 0x00000000, + 0x00000003, 0x000200f8, 0x00000005, 0x0004003b, 0x0000000b, 0x000000c3, 0x00000007, 0x0004003b, 0x0000000b, 0x000000c4, + 0x00000007, 0x0004003b, 0x0000000b, 0x000000c5, 0x00000007, 0x0004003b, 0x0000000b, 0x000000c6, 0x00000007, 0x00050041, + 0x00000092, 0x00000093, 0x00000090, 0x0000003e, 0x0003003e, 0x00000093, 0x00000091, 0x00060041, 0x00000098, 0x00000099, + 0x00000097, 0x00000022, 0x00000022, 0x0004003d, 0x0000000a, 0x0000009a, 0x00000099, 0x000500c7, 0x0000000a, 0x0000009b, + 0x0000009a, 0x0000002d, 0x000500ab, 0x00000006, 0x0000009c, 0x0000009b, 0x0000002e, 0x000300f7, 0x0000009e, 0x00000000, + 0x000400fa, 0x0000009c, 0x0000009d, 0x0000009e, 0x000200f8, 0x0000009d, 0x0004003d, 0x00000021, 0x000000a1, 0x000000a0, + 0x0004007c, 0x0000000a, 0x000000a2, 0x000000a1, 0x00050041, 0x00000023, 0x000000a6, 0x000000a5, 0x00000022, 0x0004003d, + 0x0000000a, 0x000000a7, 0x000000a6, 0x000500ae, 0x00000006, 0x000000a8, 0x000000a2, 0x000000a7, 0x000300f7, 0x000000aa, + 0x00000000, 0x000400fa, 0x000000a8, 0x000000a9, 0x000000aa, 0x000200f8, 0x000000a9, 0x000100fd, 0x000200f8, 0x000000aa, + 0x000200f9, 0x0000009e, 0x000200f8, 0x0000009e, 0x0004003d, 0x00000021, 0x000000b1, 0x000000a0, 0x0004007c, 0x0000000a, + 0x000000b2, 0x000000b1, 0x00060041, 0x00000098, 0x000000b3, 0x00000097, 0x00000022, 0x0000003e, 0x0004003d, 0x0000000a, + 0x000000b4, 0x000000b3, 0x00050084, 0x0000000a, 0x000000b5, 0x000000b2, 0x000000b4, 0x00060041, 0x00000098, 0x000000b6, + 0x00000097, 0x00000022, 0x0000004e, 0x0004003d, 0x0000000a, 0x000000b7, 0x000000b6, 0x00050080, 0x0000000a, 0x000000b8, + 0x000000b5, 0x000000b7, 0x00060041, 0x00000023, 0x000000b9, 0x000000b0, 0x00000022, 0x000000b8, 0x0004003d, 0x0000000a, + 0x000000ba, 0x000000b9, 0x000500ab, 0x00000006, 0x000000bc, 0x000000ba, 0x0000002e, 0x000300f7, 0x000000be, 0x00000000, + 0x000400fa, 0x000000bc, 0x000000bd, 0x000000be, 0x000200f8, 0x000000bd, 0x0004003d, 0x00000021, 0x000000c1, 0x000000a0, + 0x0004007c, 0x0000000a, 0x000000c2, 0x000000c1, 0x0003003e, 0x000000c3, 0x000000bf, 0x0003003e, 0x000000c4, 0x000000c0, + 0x0003003e, 0x000000c5, 0x000000c2, 0x0003003e, 0x000000c6, 0x000000ba, 0x00080039, 0x00000002, 0x000000c8, 0x0000001a, + 0x000000c3, 0x000000c4, 0x000000c5, 0x000000c6, 0x000200f9, 0x000000be, 0x000200f8, 0x000000be, 0x000100fd, 0x00010038, + 0x00050036, 0x00000006, 0x00000008, 0x00000000, 0x00000007, 0x000200f8, 0x00000009, 0x00060041, 0x00000023, 0x00000024, + 0x00000020, 0x00000022, 0x00000022, 0x0004003d, 0x0000000a, 0x00000025, 0x00000024, 0x00060041, 0x00000023, 0x0000002c, + 0x0000002a, 0x00000022, 0x00000025, 0x000700ea, 0x0000000a, 0x0000002f, 0x0000002c, 0x0000002d, 0x0000002e, 0x0000002d, + 0x000500ae, 0x00000006, 0x00000032, 0x0000002f, 0x00000031, 0x000200fe, 0x00000032, 0x00010038, 0x00050036, 0x00000002, + 0x00000013, 0x00000000, 0x0000000c, 0x00030037, 0x0000000b, 0x0000000d, 0x00030037, 0x0000000b, 0x0000000e, 0x00030037, + 0x0000000b, 0x0000000f, 0x00030037, 0x0000000b, 0x00000010, 0x00030037, 0x0000000b, 0x00000011, 0x00030037, 0x0000000b, + 0x00000012, 0x000200f8, 0x00000014, 0x00040039, 0x00000006, 0x00000035, 0x00000008, 0x000300f7, 0x00000037, 0x00000000, + 0x000400fa, 0x00000035, 0x00000036, 0x00000037, 0x000200f8, 0x00000036, 0x000100fd, 0x000200f8, 0x00000037, 0x00050041, + 0x00000023, 0x0000003f, 0x0000003d, 0x0000003e, 0x000700ea, 0x0000000a, 0x00000041, 0x0000003f, 0x0000002d, 0x0000002e, + 0x00000040, 0x00050080, 0x0000000a, 0x00000045, 0x00000041, 0x00000040, 0x00050044, 0x0000000a, 0x00000046, 0x0000003d, + 0x00000002, 0x0004007c, 0x00000021, 0x00000047, 0x00000046, 0x0004007c, 0x0000000a, 0x00000048, 0x00000047, 0x000500ac, + 0x00000006, 0x00000049, 0x00000045, 0x00000048, 0x000300f7, 0x0000004c, 0x00000000, 0x000400fa, 0x00000049, 0x0000004b, + 0x0000004c, 0x000200f8, 0x0000004b, 0x000100fd, 0x000200f8, 0x0000004c, 0x00060041, 0x00000023, 0x00000051, 0x0000003d, + 0x0000004e, 0x00000041, 0x0003003e, 0x00000051, 0x00000040, 0x00050080, 0x0000000a, 0x00000054, 0x00000041, 0x00000053, + 0x00060041, 0x00000023, 0x00000059, 0x00000058, 0x00000022, 0x00000022, 0x0004003d, 0x0000000a, 0x0000005a, 0x00000059, + 0x00060041, 0x00000023, 0x0000005b, 0x0000003d, 0x0000004e, 0x00000054, 0x0003003e, 0x0000005b, 0x0000005a, 0x00050080, + 0x0000000a, 0x0000005e, 0x00000041, 0x0000005d, 0x00060041, 0x00000023, 0x0000005f, 0x00000020, 0x00000022, 0x00000022, + 0x0004003d, 0x0000000a, 0x00000060, 0x0000005f, 0x00060041, 0x00000023, 0x00000061, 0x0000003d, 0x0000004e, 0x0000005e, + 0x0003003e, 0x00000061, 0x00000060, 0x00050080, 0x0000000a, 0x00000064, 0x00000041, 0x00000063, 0x0004003d, 0x0000000a, + 0x00000065, 0x0000000d, 0x00060041, 0x00000023, 0x00000066, 0x0000003d, 0x0000004e, 0x00000064, 0x0003003e, 0x00000066, + 0x00000065, 0x00050080, 0x0000000a, 0x00000069, 0x00000041, 0x00000068, 0x0004003d, 0x0000000a, 0x0000006a, 0x0000000e, + 0x00060041, 0x00000023, 0x0000006b, 0x0000003d, 0x0000004e, 0x00000069, 0x0003003e, 0x0000006b, 0x0000006a, 0x00050080, + 0x0000000a, 0x0000006e, 0x00000041, 0x0000006d, 0x0004003d, 0x0000000a, 0x0000006f, 0x0000000f, 0x00060041, 0x00000023, + 0x00000070, 0x0000003d, 0x0000004e, 0x0000006e, 0x0003003e, 0x00000070, 0x0000006f, 0x00050080, 0x0000000a, 0x00000073, + 0x00000041, 0x00000072, 0x0004003d, 0x0000000a, 0x00000074, 0x00000010, 0x00060041, 0x00000023, 0x00000075, 0x0000003d, + 0x0000004e, 0x00000073, 0x0003003e, 0x00000075, 0x00000074, 0x00050080, 0x0000000a, 0x00000078, 0x00000041, 0x00000077, + 0x0004003d, 0x0000000a, 0x00000079, 0x00000011, 0x00060041, 0x00000023, 0x0000007a, 0x0000003d, 0x0000004e, 0x00000078, + 0x0003003e, 0x0000007a, 0x00000079, 0x00050080, 0x0000000a, 0x0000007d, 0x00000041, 0x0000007c, 0x0004003d, 0x0000000a, + 0x0000007e, 0x00000012, 0x00060041, 0x00000023, 0x0000007f, 0x0000003d, 0x0000004e, 0x0000007d, 0x0003003e, 0x0000007f, + 0x0000007e, 0x000100fd, 0x00010038, 0x00050036, 0x00000002, 0x0000001a, 0x00000000, 0x00000015, 0x00030037, 0x0000000b, + 0x00000016, 0x00030037, 0x0000000b, 0x00000017, 0x00030037, 0x0000000b, 0x00000018, 0x00030037, 0x0000000b, 0x00000019, + 0x000200f8, 0x0000001b, 0x0004003b, 0x0000000b, 0x00000080, 0x00000007, 0x0004003b, 0x0000000b, 0x00000082, 0x00000007, + 0x0004003b, 0x0000000b, 0x00000084, 0x00000007, 0x0004003b, 0x0000000b, 0x00000086, 0x00000007, 0x0004003b, 0x0000000b, + 0x00000088, 0x00000007, 0x0004003b, 0x0000000b, 0x00000089, 0x00000007, 0x0004003d, 0x0000000a, 0x00000081, 0x00000016, + 0x0003003e, 0x00000080, 0x00000081, 0x0004003d, 0x0000000a, 0x00000083, 0x00000017, 0x0003003e, 0x00000082, 0x00000083, + 0x0004003d, 0x0000000a, 0x00000085, 0x00000018, 0x0003003e, 0x00000084, 0x00000085, 0x0004003d, 0x0000000a, 0x00000087, + 0x00000019, 0x0003003e, 0x00000086, 0x00000087, 0x0003003e, 0x00000088, 0x0000002e, 0x0003003e, 0x00000089, 0x0000002e, + 0x000a0039, 0x00000002, 0x0000008a, 0x00000013, 0x00000080, 0x00000082, 0x00000084, 0x00000086, 0x00000088, 0x00000089, + 0x000100fd, 0x00010038, +}; diff --git a/layers/vulkan/generated/cmd_validation_first_instance_vert.h b/layers/vulkan/generated/cmd_validation_first_instance_vert.h new file mode 100644 index 00000000000..fa6a907c6f0 --- /dev/null +++ b/layers/vulkan/generated/cmd_validation_first_instance_vert.h @@ -0,0 +1,30 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See generate_spirv.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2021-2024 The Khronos Group Inc. + * Copyright (c) 2021-2024 Valve Corporation + * Copyright (c) 2021-2024 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************/ + +#pragma once + +#include + +// To view SPIR-V, copy contents of array and paste in https://www.khronos.org/spir/visualizer/ +extern const uint32_t cmd_validation_first_instance_vert_size; +extern const uint32_t cmd_validation_first_instance_vert[]; diff --git a/layers/vulkan/generated/cmd_validation_trace_rays_rgen.cpp b/layers/vulkan/generated/cmd_validation_trace_rays_rgen.cpp index 474889f636a..a1ec0b443bd 100644 --- a/layers/vulkan/generated/cmd_validation_trace_rays_rgen.cpp +++ b/layers/vulkan/generated/cmd_validation_trace_rays_rgen.cpp @@ -24,132 +24,153 @@ #include "cmd_validation_trace_rays_rgen.h" // To view SPIR-V, copy contents of array and paste in https://www.khronos.org/spir/visualizer/ -[[maybe_unused]] const uint32_t cmd_validation_trace_rays_rgen_size = 1252; -[[maybe_unused]] const uint32_t cmd_validation_trace_rays_rgen[1252] = { - 0x07230203, 0x00010500, 0x0008000b, 0x000000af, 0x00000000, 0x00020011, 0x0000117f, 0x00020011, 0x000014e3, 0x0006000a, +[[maybe_unused]] const uint32_t cmd_validation_trace_rays_rgen_size = 1470; +[[maybe_unused]] const uint32_t cmd_validation_trace_rays_rgen[1470] = { + 0x07230203, 0x00010500, 0x0008000b, 0x000000cd, 0x00000000, 0x00020011, 0x0000117f, 0x00020011, 0x000014e3, 0x0006000a, 0x5f565053, 0x5f52484b, 0x5f796172, 0x63617274, 0x00676e69, 0x0006000b, 0x00000001, 0x4c534c47, 0x6474732e, 0x3035342e, - 0x00000000, 0x0003000e, 0x000014e4, 0x00000001, 0x000a000f, 0x000014c1, 0x00000004, 0x6e69616d, 0x00000000, 0x00000017, - 0x00000021, 0x00000034, 0x0000004f, 0x00000072, 0x00030003, 0x00000002, 0x000001cc, 0x00070004, 0x415f4c47, 0x675f4252, + 0x00000000, 0x0003000e, 0x000014e4, 0x00000001, 0x000a000f, 0x000014c1, 0x00000004, 0x6e69616d, 0x00000000, 0x00000020, + 0x0000002a, 0x0000003d, 0x00000058, 0x00000090, 0x00030003, 0x00000002, 0x000001cc, 0x00070004, 0x415f4c47, 0x675f4252, 0x735f7570, 0x65646168, 0x6e695f72, 0x00343674, 0x00070004, 0x455f4c47, 0x625f5458, 0x65666675, 0x65725f72, 0x65726566, 0x0065636e, 0x00060004, 0x455f4c47, 0x725f5458, 0x745f7961, 0x69636172, 0x0000676e, 0x000a0004, 0x475f4c47, 0x4c474f4f, 0x70635f45, 0x74735f70, 0x5f656c79, 0x656e696c, 0x7269645f, 0x69746365, 0x00006576, 0x00080004, 0x475f4c47, 0x4c474f4f, 0x6e695f45, 0x64756c63, 0x69645f65, 0x74636572, 0x00657669, 0x00040005, 0x00000004, 0x6e69616d, 0x00000000, 0x00090005, - 0x00000008, 0x4378614d, 0x7245646d, 0x73726f72, 0x6e756f43, 0x61655274, 0x64656863, 0x00000028, 0x00090005, 0x00000011, - 0x61757047, 0x676f4c76, 0x6f727245, 0x31752872, 0x3b31753b, 0x753b3175, 0x00003b31, 0x00050005, 0x0000000d, 0x6f727265, - 0x72675f72, 0x0070756f, 0x00060005, 0x0000000e, 0x6f727265, 0x75735f72, 0x6f635f62, 0x00006564, 0x00040005, 0x0000000f, - 0x61726170, 0x00305f6d, 0x00040005, 0x00000010, 0x61726170, 0x00315f6d, 0x00070005, 0x00000015, 0x6f736552, 0x65637275, - 0x65646e49, 0x66754278, 0x00726566, 0x00070006, 0x00000015, 0x00000000, 0x6f736572, 0x65637275, 0x646e695f, 0x00007865, - 0x00030005, 0x00000017, 0x00000000, 0x00080005, 0x0000001f, 0x45646d43, 0x726f7272, 0x756f4373, 0x7542746e, 0x72656666, - 0x00000000, 0x00080006, 0x0000001f, 0x00000000, 0x5f646d63, 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, 0x00030005, - 0x00000021, 0x00000000, 0x00040005, 0x00000030, 0x695f6f76, 0x00007864, 0x00050005, 0x00000032, 0x6f727245, 0x66754272, - 0x00726566, 0x00050006, 0x00000032, 0x00000000, 0x67616c66, 0x00000073, 0x00070006, 0x00000032, 0x00000001, 0x6f727265, - 0x635f7372, 0x746e756f, 0x00000000, 0x00070006, 0x00000032, 0x00000002, 0x6f727265, 0x625f7372, 0x65666675, 0x00000072, - 0x00030005, 0x00000034, 0x00000000, 0x00070005, 0x0000004d, 0x69746341, 0x6e496e6f, 0x42786564, 0x65666675, 0x00000072, - 0x00070006, 0x0000004d, 0x00000000, 0x69746361, 0x695f6e6f, 0x7865646e, 0x00000000, 0x00030005, 0x0000004f, 0x00000000, - 0x00060005, 0x0000006e, 0x68737550, 0x736e6f43, 0x746e6174, 0x00000073, 0x00070006, 0x0000006e, 0x00000000, 0x69646e69, - 0x74636572, 0x7461645f, 0x00000061, 0x00090006, 0x0000006e, 0x00000001, 0x5f796172, 0x72657571, 0x69775f79, 0x5f687464, - 0x696d696c, 0x00000074, 0x00090006, 0x0000006e, 0x00000002, 0x5f796172, 0x72657571, 0x65685f79, 0x74686769, 0x6d696c5f, - 0x00007469, 0x00090006, 0x0000006e, 0x00000003, 0x5f796172, 0x72657571, 0x65645f79, 0x5f687470, 0x696d696c, 0x00000074, - 0x000a0005, 0x0000006f, 0x72546b56, 0x52656361, 0x49737961, 0x7269646e, 0x43746365, 0x616d6d6f, 0x484b646e, 0x00000052, - 0x00050006, 0x0000006f, 0x00000000, 0x74646977, 0x00000068, 0x00050006, 0x0000006f, 0x00000001, 0x67696568, 0x00007468, - 0x00050006, 0x0000006f, 0x00000002, 0x74706564, 0x00000068, 0x00090005, 0x00000070, 0x69646e49, 0x74636572, 0x6d6d6f43, - 0x52646e61, 0x72656665, 0x65636e65, 0x00000000, 0x00090006, 0x00000070, 0x00000000, 0x5f796172, 0x72657571, 0x69645f79, - 0x736e656d, 0x736e6f69, 0x00000000, 0x00030005, 0x00000072, 0x00000000, 0x00040005, 0x00000081, 0x61726170, 0x0000006d, - 0x00040005, 0x00000082, 0x61726170, 0x0000006d, 0x00040005, 0x00000083, 0x61726170, 0x0000006d, 0x00040005, 0x00000086, - 0x61726170, 0x0000006d, 0x00040005, 0x00000094, 0x61726170, 0x0000006d, 0x00040005, 0x00000095, 0x61726170, 0x0000006d, - 0x00040005, 0x00000096, 0x61726170, 0x0000006d, 0x00040005, 0x00000099, 0x61726170, 0x0000006d, 0x00040005, 0x000000a8, - 0x61726170, 0x0000006d, 0x00040005, 0x000000a9, 0x61726170, 0x0000006d, 0x00040005, 0x000000aa, 0x61726170, 0x0000006d, - 0x00040005, 0x000000ad, 0x61726170, 0x0000006d, 0x00040047, 0x00000014, 0x00000006, 0x00000004, 0x00030047, 0x00000015, - 0x00000002, 0x00050048, 0x00000015, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000017, 0x00000021, 0x00000002, - 0x00040047, 0x00000017, 0x00000022, 0x00000000, 0x00040047, 0x0000001e, 0x00000006, 0x00000004, 0x00030047, 0x0000001f, - 0x00000002, 0x00050048, 0x0000001f, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000021, 0x00000021, 0x00000003, - 0x00040047, 0x00000021, 0x00000022, 0x00000000, 0x00040047, 0x00000031, 0x00000006, 0x00000004, 0x00030047, 0x00000032, - 0x00000002, 0x00050048, 0x00000032, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x00000032, 0x00000001, 0x00000023, - 0x00000004, 0x00050048, 0x00000032, 0x00000002, 0x00000023, 0x00000008, 0x00040047, 0x00000034, 0x00000021, 0x00000000, - 0x00040047, 0x00000034, 0x00000022, 0x00000000, 0x00040047, 0x0000004c, 0x00000006, 0x00000004, 0x00030047, 0x0000004d, - 0x00000002, 0x00050048, 0x0000004d, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x0000004f, 0x00000021, 0x00000001, - 0x00040047, 0x0000004f, 0x00000022, 0x00000000, 0x00030047, 0x0000006e, 0x00000002, 0x00050048, 0x0000006e, 0x00000000, - 0x00000023, 0x00000000, 0x00050048, 0x0000006e, 0x00000001, 0x00000023, 0x00000008, 0x00050048, 0x0000006e, 0x00000002, - 0x00000023, 0x0000000c, 0x00050048, 0x0000006e, 0x00000003, 0x00000023, 0x00000010, 0x00050048, 0x0000006f, 0x00000000, - 0x00000023, 0x00000000, 0x00050048, 0x0000006f, 0x00000001, 0x00000023, 0x00000004, 0x00050048, 0x0000006f, 0x00000002, - 0x00000023, 0x00000008, 0x00030047, 0x00000070, 0x00000002, 0x00050048, 0x00000070, 0x00000000, 0x00000023, 0x00000000, + 0x00000008, 0x4378614d, 0x7245646d, 0x73726f72, 0x6e756f43, 0x61655274, 0x64656863, 0x00000028, 0x000b0005, 0x00000013, + 0x61757047, 0x676f4c76, 0x6f727245, 0x75283472, 0x31753b31, 0x3b31753b, 0x753b3175, 0x31753b31, 0x0000003b, 0x00050005, + 0x0000000d, 0x6f727265, 0x72675f72, 0x0070756f, 0x00060005, 0x0000000e, 0x6f727265, 0x75735f72, 0x6f635f62, 0x00006564, + 0x00040005, 0x0000000f, 0x61726170, 0x00305f6d, 0x00040005, 0x00000010, 0x61726170, 0x00315f6d, 0x00040005, 0x00000011, + 0x61726170, 0x00325f6d, 0x00040005, 0x00000012, 0x61726170, 0x00335f6d, 0x00090005, 0x0000001a, 0x61757047, 0x676f4c76, + 0x6f727245, 0x75283272, 0x31753b31, 0x3b31753b, 0x003b3175, 0x00050005, 0x00000016, 0x6f727265, 0x72675f72, 0x0070756f, + 0x00060005, 0x00000017, 0x6f727265, 0x75735f72, 0x6f635f62, 0x00006564, 0x00040005, 0x00000018, 0x61726170, 0x00305f6d, + 0x00040005, 0x00000019, 0x61726170, 0x00315f6d, 0x00070005, 0x0000001e, 0x6f736552, 0x65637275, 0x65646e49, 0x66754278, + 0x00726566, 0x00070006, 0x0000001e, 0x00000000, 0x6f736572, 0x65637275, 0x646e695f, 0x00007865, 0x00030005, 0x00000020, + 0x00000000, 0x00080005, 0x00000028, 0x45646d43, 0x726f7272, 0x756f4373, 0x7542746e, 0x72656666, 0x00000000, 0x00080006, + 0x00000028, 0x00000000, 0x5f646d63, 0x6f727265, 0x635f7372, 0x746e756f, 0x00000000, 0x00030005, 0x0000002a, 0x00000000, + 0x00040005, 0x00000039, 0x695f6f76, 0x00007864, 0x00050005, 0x0000003b, 0x6f727245, 0x66754272, 0x00726566, 0x00050006, + 0x0000003b, 0x00000000, 0x67616c66, 0x00000073, 0x00070006, 0x0000003b, 0x00000001, 0x6f727265, 0x635f7372, 0x746e756f, + 0x00000000, 0x00070006, 0x0000003b, 0x00000002, 0x6f727265, 0x625f7372, 0x65666675, 0x00000072, 0x00030005, 0x0000003d, + 0x00000000, 0x00070005, 0x00000056, 0x69746341, 0x6e496e6f, 0x42786564, 0x65666675, 0x00000072, 0x00070006, 0x00000056, + 0x00000000, 0x69746361, 0x695f6e6f, 0x7865646e, 0x00000000, 0x00030005, 0x00000058, 0x00000000, 0x00040005, 0x00000080, + 0x61726170, 0x0000006d, 0x00040005, 0x00000082, 0x61726170, 0x0000006d, 0x00040005, 0x00000084, 0x61726170, 0x0000006d, + 0x00040005, 0x00000086, 0x61726170, 0x0000006d, 0x00040005, 0x00000088, 0x61726170, 0x0000006d, 0x00040005, 0x00000089, + 0x61726170, 0x0000006d, 0x00060005, 0x0000008c, 0x68737550, 0x736e6f43, 0x746e6174, 0x00000073, 0x00070006, 0x0000008c, + 0x00000000, 0x69646e69, 0x74636572, 0x7461645f, 0x00000061, 0x00090006, 0x0000008c, 0x00000001, 0x5f796172, 0x72657571, + 0x69775f79, 0x5f687464, 0x696d696c, 0x00000074, 0x00090006, 0x0000008c, 0x00000002, 0x5f796172, 0x72657571, 0x65685f79, + 0x74686769, 0x6d696c5f, 0x00007469, 0x00090006, 0x0000008c, 0x00000003, 0x5f796172, 0x72657571, 0x65645f79, 0x5f687470, + 0x696d696c, 0x00000074, 0x000a0005, 0x0000008d, 0x72546b56, 0x52656361, 0x49737961, 0x7269646e, 0x43746365, 0x616d6d6f, + 0x484b646e, 0x00000052, 0x00050006, 0x0000008d, 0x00000000, 0x74646977, 0x00000068, 0x00050006, 0x0000008d, 0x00000001, + 0x67696568, 0x00007468, 0x00050006, 0x0000008d, 0x00000002, 0x74706564, 0x00000068, 0x00090005, 0x0000008e, 0x69646e49, + 0x74636572, 0x6d6d6f43, 0x52646e61, 0x72656665, 0x65636e65, 0x00000000, 0x00090006, 0x0000008e, 0x00000000, 0x5f796172, + 0x72657571, 0x69645f79, 0x736e656d, 0x736e6f69, 0x00000000, 0x00030005, 0x00000090, 0x00000000, 0x00040005, 0x0000009f, + 0x61726170, 0x0000006d, 0x00040005, 0x000000a0, 0x61726170, 0x0000006d, 0x00040005, 0x000000a1, 0x61726170, 0x0000006d, + 0x00040005, 0x000000a4, 0x61726170, 0x0000006d, 0x00040005, 0x000000b2, 0x61726170, 0x0000006d, 0x00040005, 0x000000b3, + 0x61726170, 0x0000006d, 0x00040005, 0x000000b4, 0x61726170, 0x0000006d, 0x00040005, 0x000000b7, 0x61726170, 0x0000006d, + 0x00040005, 0x000000c6, 0x61726170, 0x0000006d, 0x00040005, 0x000000c7, 0x61726170, 0x0000006d, 0x00040005, 0x000000c8, + 0x61726170, 0x0000006d, 0x00040005, 0x000000cb, 0x61726170, 0x0000006d, 0x00040047, 0x0000001d, 0x00000006, 0x00000004, + 0x00030047, 0x0000001e, 0x00000002, 0x00040048, 0x0000001e, 0x00000000, 0x00000018, 0x00050048, 0x0000001e, 0x00000000, + 0x00000023, 0x00000000, 0x00040047, 0x00000020, 0x00000021, 0x00000002, 0x00040047, 0x00000020, 0x00000022, 0x00000000, + 0x00040047, 0x00000027, 0x00000006, 0x00000004, 0x00030047, 0x00000028, 0x00000002, 0x00050048, 0x00000028, 0x00000000, + 0x00000023, 0x00000000, 0x00040047, 0x0000002a, 0x00000021, 0x00000003, 0x00040047, 0x0000002a, 0x00000022, 0x00000000, + 0x00040047, 0x0000003a, 0x00000006, 0x00000004, 0x00030047, 0x0000003b, 0x00000002, 0x00050048, 0x0000003b, 0x00000000, + 0x00000023, 0x00000000, 0x00050048, 0x0000003b, 0x00000001, 0x00000023, 0x00000004, 0x00050048, 0x0000003b, 0x00000002, + 0x00000023, 0x00000008, 0x00040047, 0x0000003d, 0x00000021, 0x00000000, 0x00040047, 0x0000003d, 0x00000022, 0x00000000, + 0x00040047, 0x00000055, 0x00000006, 0x00000004, 0x00030047, 0x00000056, 0x00000002, 0x00040048, 0x00000056, 0x00000000, + 0x00000018, 0x00050048, 0x00000056, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000058, 0x00000021, 0x00000001, + 0x00040047, 0x00000058, 0x00000022, 0x00000000, 0x00030047, 0x0000008c, 0x00000002, 0x00050048, 0x0000008c, 0x00000000, + 0x00000023, 0x00000000, 0x00050048, 0x0000008c, 0x00000001, 0x00000023, 0x00000008, 0x00050048, 0x0000008c, 0x00000002, + 0x00000023, 0x0000000c, 0x00050048, 0x0000008c, 0x00000003, 0x00000023, 0x00000010, 0x00050048, 0x0000008d, 0x00000000, + 0x00000023, 0x00000000, 0x00050048, 0x0000008d, 0x00000001, 0x00000023, 0x00000004, 0x00050048, 0x0000008d, 0x00000002, + 0x00000023, 0x00000008, 0x00030047, 0x0000008e, 0x00000002, 0x00050048, 0x0000008e, 0x00000000, 0x00000023, 0x00000000, 0x00020013, 0x00000002, 0x00030021, 0x00000003, 0x00000002, 0x00020014, 0x00000006, 0x00030021, 0x00000007, 0x00000006, - 0x00040015, 0x0000000a, 0x00000020, 0x00000000, 0x00040020, 0x0000000b, 0x00000007, 0x0000000a, 0x00070021, 0x0000000c, - 0x00000002, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x0003001d, 0x00000014, 0x0000000a, 0x0003001e, 0x00000015, - 0x00000014, 0x00040020, 0x00000016, 0x0000000c, 0x00000015, 0x0004003b, 0x00000016, 0x00000017, 0x0000000c, 0x00040015, - 0x00000018, 0x00000020, 0x00000001, 0x0004002b, 0x00000018, 0x00000019, 0x00000000, 0x00040020, 0x0000001a, 0x0000000c, - 0x0000000a, 0x0003001d, 0x0000001e, 0x0000000a, 0x0003001e, 0x0000001f, 0x0000001e, 0x00040020, 0x00000020, 0x0000000c, - 0x0000001f, 0x0004003b, 0x00000020, 0x00000021, 0x0000000c, 0x0004002b, 0x0000000a, 0x00000024, 0x00000001, 0x0004002b, - 0x0000000a, 0x00000025, 0x00000000, 0x0004002b, 0x0000000a, 0x00000028, 0x00000006, 0x0003001d, 0x00000031, 0x0000000a, - 0x0005001e, 0x00000032, 0x0000000a, 0x0000000a, 0x00000031, 0x00040020, 0x00000033, 0x0000000c, 0x00000032, 0x0004003b, - 0x00000033, 0x00000034, 0x0000000c, 0x0004002b, 0x00000018, 0x00000035, 0x00000001, 0x0004002b, 0x0000000a, 0x00000037, - 0x00000010, 0x0004002b, 0x00000018, 0x00000045, 0x00000002, 0x0004002b, 0x0000000a, 0x0000004a, 0x00000007, 0x0003001d, - 0x0000004c, 0x0000000a, 0x0003001e, 0x0000004d, 0x0000004c, 0x00040020, 0x0000004e, 0x0000000c, 0x0000004d, 0x0004003b, - 0x0000004e, 0x0000004f, 0x0000000c, 0x0004002b, 0x0000000a, 0x00000054, 0x00000008, 0x0004002b, 0x0000000a, 0x0000005a, - 0x00000009, 0x0004002b, 0x0000000a, 0x0000005f, 0x0000000a, 0x0004002b, 0x0000000a, 0x00000064, 0x0000000b, 0x0004002b, - 0x0000000a, 0x00000069, 0x0000000c, 0x00030027, 0x0000006d, 0x000014e5, 0x0006001e, 0x0000006e, 0x0000006d, 0x0000000a, - 0x0000000a, 0x0000000a, 0x0005001e, 0x0000006f, 0x0000000a, 0x0000000a, 0x0000000a, 0x0003001e, 0x00000070, 0x0000006f, - 0x00040020, 0x0000006d, 0x000014e5, 0x00000070, 0x00040020, 0x00000071, 0x00000009, 0x0000006e, 0x0004003b, 0x00000071, - 0x00000072, 0x00000009, 0x00040020, 0x00000073, 0x00000009, 0x0000006d, 0x00040020, 0x00000076, 0x000014e5, 0x0000000a, - 0x00040020, 0x00000079, 0x00000009, 0x0000000a, 0x0004002b, 0x0000000a, 0x00000091, 0x00000002, 0x0004002b, 0x00000018, - 0x0000009f, 0x00000003, 0x0004002b, 0x0000000a, 0x000000a5, 0x00000003, 0x00050036, 0x00000002, 0x00000004, 0x00000000, - 0x00000003, 0x000200f8, 0x00000005, 0x0004003b, 0x0000000b, 0x00000081, 0x00000007, 0x0004003b, 0x0000000b, 0x00000082, - 0x00000007, 0x0004003b, 0x0000000b, 0x00000083, 0x00000007, 0x0004003b, 0x0000000b, 0x00000086, 0x00000007, 0x0004003b, - 0x0000000b, 0x00000094, 0x00000007, 0x0004003b, 0x0000000b, 0x00000095, 0x00000007, 0x0004003b, 0x0000000b, 0x00000096, - 0x00000007, 0x0004003b, 0x0000000b, 0x00000099, 0x00000007, 0x0004003b, 0x0000000b, 0x000000a8, 0x00000007, 0x0004003b, - 0x0000000b, 0x000000a9, 0x00000007, 0x0004003b, 0x0000000b, 0x000000aa, 0x00000007, 0x0004003b, 0x0000000b, 0x000000ad, - 0x00000007, 0x00050041, 0x00000073, 0x00000074, 0x00000072, 0x00000019, 0x0004003d, 0x0000006d, 0x00000075, 0x00000074, - 0x00060041, 0x00000076, 0x00000077, 0x00000075, 0x00000019, 0x00000019, 0x0006003d, 0x0000000a, 0x00000078, 0x00000077, - 0x00000002, 0x00000010, 0x00050041, 0x00000079, 0x0000007a, 0x00000072, 0x00000035, 0x0004003d, 0x0000000a, 0x0000007b, - 0x0000007a, 0x000500ac, 0x00000006, 0x0000007c, 0x00000078, 0x0000007b, 0x000300f7, 0x0000007e, 0x00000000, 0x000400fa, - 0x0000007c, 0x0000007d, 0x0000007e, 0x000200f8, 0x0000007d, 0x00050041, 0x00000073, 0x0000007f, 0x00000072, 0x00000019, - 0x0004003d, 0x0000006d, 0x00000080, 0x0000007f, 0x0003003e, 0x00000081, 0x00000028, 0x0003003e, 0x00000082, 0x00000024, - 0x00060041, 0x00000076, 0x00000084, 0x00000080, 0x00000019, 0x00000019, 0x0006003d, 0x0000000a, 0x00000085, 0x00000084, - 0x00000002, 0x00000010, 0x0003003e, 0x00000083, 0x00000085, 0x0003003e, 0x00000086, 0x00000025, 0x00080039, 0x00000002, - 0x00000087, 0x00000011, 0x00000081, 0x00000082, 0x00000083, 0x00000086, 0x000200f9, 0x0000007e, 0x000200f8, 0x0000007e, - 0x00050041, 0x00000073, 0x00000088, 0x00000072, 0x00000019, 0x0004003d, 0x0000006d, 0x00000089, 0x00000088, 0x00060041, - 0x00000076, 0x0000008a, 0x00000089, 0x00000019, 0x00000035, 0x0006003d, 0x0000000a, 0x0000008b, 0x0000008a, 0x00000002, - 0x00000004, 0x00050041, 0x00000079, 0x0000008c, 0x00000072, 0x00000045, 0x0004003d, 0x0000000a, 0x0000008d, 0x0000008c, - 0x000500ac, 0x00000006, 0x0000008e, 0x0000008b, 0x0000008d, 0x000300f7, 0x00000090, 0x00000000, 0x000400fa, 0x0000008e, - 0x0000008f, 0x00000090, 0x000200f8, 0x0000008f, 0x00050041, 0x00000073, 0x00000092, 0x00000072, 0x00000019, 0x0004003d, - 0x0000006d, 0x00000093, 0x00000092, 0x0003003e, 0x00000094, 0x00000028, 0x0003003e, 0x00000095, 0x00000091, 0x00060041, - 0x00000076, 0x00000097, 0x00000093, 0x00000019, 0x00000035, 0x0006003d, 0x0000000a, 0x00000098, 0x00000097, 0x00000002, - 0x00000004, 0x0003003e, 0x00000096, 0x00000098, 0x0003003e, 0x00000099, 0x00000025, 0x00080039, 0x00000002, 0x0000009a, - 0x00000011, 0x00000094, 0x00000095, 0x00000096, 0x00000099, 0x000200f9, 0x00000090, 0x000200f8, 0x00000090, 0x00050041, - 0x00000073, 0x0000009b, 0x00000072, 0x00000019, 0x0004003d, 0x0000006d, 0x0000009c, 0x0000009b, 0x00060041, 0x00000076, - 0x0000009d, 0x0000009c, 0x00000019, 0x00000045, 0x0006003d, 0x0000000a, 0x0000009e, 0x0000009d, 0x00000002, 0x00000008, - 0x00050041, 0x00000079, 0x000000a0, 0x00000072, 0x0000009f, 0x0004003d, 0x0000000a, 0x000000a1, 0x000000a0, 0x000500ac, - 0x00000006, 0x000000a2, 0x0000009e, 0x000000a1, 0x000300f7, 0x000000a4, 0x00000000, 0x000400fa, 0x000000a2, 0x000000a3, - 0x000000a4, 0x000200f8, 0x000000a3, 0x00050041, 0x00000073, 0x000000a6, 0x00000072, 0x00000019, 0x0004003d, 0x0000006d, - 0x000000a7, 0x000000a6, 0x0003003e, 0x000000a8, 0x00000028, 0x0003003e, 0x000000a9, 0x000000a5, 0x00060041, 0x00000076, - 0x000000ab, 0x000000a7, 0x00000019, 0x00000045, 0x0006003d, 0x0000000a, 0x000000ac, 0x000000ab, 0x00000002, 0x00000008, - 0x0003003e, 0x000000aa, 0x000000ac, 0x0003003e, 0x000000ad, 0x00000025, 0x00080039, 0x00000002, 0x000000ae, 0x00000011, - 0x000000a8, 0x000000a9, 0x000000aa, 0x000000ad, 0x000200f9, 0x000000a4, 0x000200f8, 0x000000a4, 0x000100fd, 0x00010038, - 0x00050036, 0x00000006, 0x00000008, 0x00000000, 0x00000007, 0x000200f8, 0x00000009, 0x00060041, 0x0000001a, 0x0000001b, - 0x00000017, 0x00000019, 0x00000019, 0x0004003d, 0x0000000a, 0x0000001c, 0x0000001b, 0x00060041, 0x0000001a, 0x00000023, - 0x00000021, 0x00000019, 0x0000001c, 0x000700ea, 0x0000000a, 0x00000026, 0x00000023, 0x00000024, 0x00000025, 0x00000024, - 0x000500ae, 0x00000006, 0x00000029, 0x00000026, 0x00000028, 0x000200fe, 0x00000029, 0x00010038, 0x00050036, 0x00000002, - 0x00000011, 0x00000000, 0x0000000c, 0x00030037, 0x0000000b, 0x0000000d, 0x00030037, 0x0000000b, 0x0000000e, 0x00030037, - 0x0000000b, 0x0000000f, 0x00030037, 0x0000000b, 0x00000010, 0x000200f8, 0x00000012, 0x0004003b, 0x0000000b, 0x00000030, - 0x00000007, 0x00040039, 0x00000006, 0x0000002c, 0x00000008, 0x000300f7, 0x0000002e, 0x00000000, 0x000400fa, 0x0000002c, - 0x0000002d, 0x0000002e, 0x000200f8, 0x0000002d, 0x000100fd, 0x000200f8, 0x0000002e, 0x00050041, 0x0000001a, 0x00000036, - 0x00000034, 0x00000035, 0x000700ea, 0x0000000a, 0x00000038, 0x00000036, 0x00000024, 0x00000025, 0x00000037, 0x0003003e, - 0x00000030, 0x00000038, 0x00050080, 0x0000000a, 0x0000003c, 0x00000038, 0x00000037, 0x00050044, 0x0000000a, 0x0000003d, - 0x00000034, 0x00000002, 0x0004007c, 0x00000018, 0x0000003e, 0x0000003d, 0x0004007c, 0x0000000a, 0x0000003f, 0x0000003e, - 0x000500ac, 0x00000006, 0x00000040, 0x0000003c, 0x0000003f, 0x000300f7, 0x00000043, 0x00000000, 0x000400fa, 0x00000040, - 0x00000042, 0x00000043, 0x000200f8, 0x00000042, 0x000100fd, 0x000200f8, 0x00000043, 0x0004003d, 0x0000000a, 0x00000046, - 0x00000030, 0x00060041, 0x0000001a, 0x00000048, 0x00000034, 0x00000045, 0x00000046, 0x0003003e, 0x00000048, 0x00000037, - 0x00050080, 0x0000000a, 0x0000004b, 0x00000046, 0x0000004a, 0x00060041, 0x0000001a, 0x00000050, 0x0000004f, 0x00000019, - 0x00000019, 0x0004003d, 0x0000000a, 0x00000051, 0x00000050, 0x00060041, 0x0000001a, 0x00000052, 0x00000034, 0x00000045, - 0x0000004b, 0x0003003e, 0x00000052, 0x00000051, 0x00050080, 0x0000000a, 0x00000055, 0x00000046, 0x00000054, 0x00060041, - 0x0000001a, 0x00000056, 0x00000017, 0x00000019, 0x00000019, 0x0004003d, 0x0000000a, 0x00000057, 0x00000056, 0x00060041, - 0x0000001a, 0x00000058, 0x00000034, 0x00000045, 0x00000055, 0x0003003e, 0x00000058, 0x00000057, 0x00050080, 0x0000000a, - 0x0000005b, 0x00000046, 0x0000005a, 0x0004003d, 0x0000000a, 0x0000005c, 0x0000000d, 0x00060041, 0x0000001a, 0x0000005d, - 0x00000034, 0x00000045, 0x0000005b, 0x0003003e, 0x0000005d, 0x0000005c, 0x00050080, 0x0000000a, 0x00000060, 0x00000046, - 0x0000005f, 0x0004003d, 0x0000000a, 0x00000061, 0x0000000e, 0x00060041, 0x0000001a, 0x00000062, 0x00000034, 0x00000045, - 0x00000060, 0x0003003e, 0x00000062, 0x00000061, 0x00050080, 0x0000000a, 0x00000065, 0x00000046, 0x00000064, 0x0004003d, - 0x0000000a, 0x00000066, 0x0000000f, 0x00060041, 0x0000001a, 0x00000067, 0x00000034, 0x00000045, 0x00000065, 0x0003003e, - 0x00000067, 0x00000066, 0x00050080, 0x0000000a, 0x0000006a, 0x00000046, 0x00000069, 0x0004003d, 0x0000000a, 0x0000006b, - 0x00000010, 0x00060041, 0x0000001a, 0x0000006c, 0x00000034, 0x00000045, 0x0000006a, 0x0003003e, 0x0000006c, 0x0000006b, - 0x000100fd, 0x00010038, + 0x00040015, 0x0000000a, 0x00000020, 0x00000000, 0x00040020, 0x0000000b, 0x00000007, 0x0000000a, 0x00090021, 0x0000000c, + 0x00000002, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x00070021, 0x00000015, 0x00000002, + 0x0000000b, 0x0000000b, 0x0000000b, 0x0000000b, 0x0003001d, 0x0000001d, 0x0000000a, 0x0003001e, 0x0000001e, 0x0000001d, + 0x00040020, 0x0000001f, 0x0000000c, 0x0000001e, 0x0004003b, 0x0000001f, 0x00000020, 0x0000000c, 0x00040015, 0x00000021, + 0x00000020, 0x00000001, 0x0004002b, 0x00000021, 0x00000022, 0x00000000, 0x00040020, 0x00000023, 0x0000000c, 0x0000000a, + 0x0003001d, 0x00000027, 0x0000000a, 0x0003001e, 0x00000028, 0x00000027, 0x00040020, 0x00000029, 0x0000000c, 0x00000028, + 0x0004003b, 0x00000029, 0x0000002a, 0x0000000c, 0x0004002b, 0x0000000a, 0x0000002d, 0x00000001, 0x0004002b, 0x0000000a, + 0x0000002e, 0x00000000, 0x0004002b, 0x0000000a, 0x00000031, 0x00000006, 0x0003001d, 0x0000003a, 0x0000000a, 0x0005001e, + 0x0000003b, 0x0000000a, 0x0000000a, 0x0000003a, 0x00040020, 0x0000003c, 0x0000000c, 0x0000003b, 0x0004003b, 0x0000003c, + 0x0000003d, 0x0000000c, 0x0004002b, 0x00000021, 0x0000003e, 0x00000001, 0x0004002b, 0x0000000a, 0x00000040, 0x00000010, + 0x0004002b, 0x00000021, 0x0000004e, 0x00000002, 0x0004002b, 0x0000000a, 0x00000053, 0x00000007, 0x0003001d, 0x00000055, + 0x0000000a, 0x0003001e, 0x00000056, 0x00000055, 0x00040020, 0x00000057, 0x0000000c, 0x00000056, 0x0004003b, 0x00000057, + 0x00000058, 0x0000000c, 0x0004002b, 0x0000000a, 0x0000005d, 0x00000008, 0x0004002b, 0x0000000a, 0x00000063, 0x00000009, + 0x0004002b, 0x0000000a, 0x00000068, 0x0000000a, 0x0004002b, 0x0000000a, 0x0000006d, 0x0000000b, 0x0004002b, 0x0000000a, + 0x00000072, 0x0000000c, 0x0004002b, 0x0000000a, 0x00000077, 0x0000000d, 0x0004002b, 0x0000000a, 0x0000007c, 0x0000000e, + 0x00030027, 0x0000008b, 0x000014e5, 0x0006001e, 0x0000008c, 0x0000008b, 0x0000000a, 0x0000000a, 0x0000000a, 0x0005001e, + 0x0000008d, 0x0000000a, 0x0000000a, 0x0000000a, 0x0003001e, 0x0000008e, 0x0000008d, 0x00040020, 0x0000008b, 0x000014e5, + 0x0000008e, 0x00040020, 0x0000008f, 0x00000009, 0x0000008c, 0x0004003b, 0x0000008f, 0x00000090, 0x00000009, 0x00040020, + 0x00000091, 0x00000009, 0x0000008b, 0x00040020, 0x00000094, 0x000014e5, 0x0000000a, 0x00040020, 0x00000097, 0x00000009, + 0x0000000a, 0x0004002b, 0x0000000a, 0x000000af, 0x00000002, 0x0004002b, 0x00000021, 0x000000bd, 0x00000003, 0x0004002b, + 0x0000000a, 0x000000c3, 0x00000003, 0x00050036, 0x00000002, 0x00000004, 0x00000000, 0x00000003, 0x000200f8, 0x00000005, + 0x0004003b, 0x0000000b, 0x0000009f, 0x00000007, 0x0004003b, 0x0000000b, 0x000000a0, 0x00000007, 0x0004003b, 0x0000000b, + 0x000000a1, 0x00000007, 0x0004003b, 0x0000000b, 0x000000a4, 0x00000007, 0x0004003b, 0x0000000b, 0x000000b2, 0x00000007, + 0x0004003b, 0x0000000b, 0x000000b3, 0x00000007, 0x0004003b, 0x0000000b, 0x000000b4, 0x00000007, 0x0004003b, 0x0000000b, + 0x000000b7, 0x00000007, 0x0004003b, 0x0000000b, 0x000000c6, 0x00000007, 0x0004003b, 0x0000000b, 0x000000c7, 0x00000007, + 0x0004003b, 0x0000000b, 0x000000c8, 0x00000007, 0x0004003b, 0x0000000b, 0x000000cb, 0x00000007, 0x00050041, 0x00000091, + 0x00000092, 0x00000090, 0x00000022, 0x0004003d, 0x0000008b, 0x00000093, 0x00000092, 0x00060041, 0x00000094, 0x00000095, + 0x00000093, 0x00000022, 0x00000022, 0x0006003d, 0x0000000a, 0x00000096, 0x00000095, 0x00000002, 0x00000010, 0x00050041, + 0x00000097, 0x00000098, 0x00000090, 0x0000003e, 0x0004003d, 0x0000000a, 0x00000099, 0x00000098, 0x000500ac, 0x00000006, + 0x0000009a, 0x00000096, 0x00000099, 0x000300f7, 0x0000009c, 0x00000000, 0x000400fa, 0x0000009a, 0x0000009b, 0x0000009c, + 0x000200f8, 0x0000009b, 0x00050041, 0x00000091, 0x0000009d, 0x00000090, 0x00000022, 0x0004003d, 0x0000008b, 0x0000009e, + 0x0000009d, 0x0003003e, 0x0000009f, 0x00000031, 0x0003003e, 0x000000a0, 0x0000002d, 0x00060041, 0x00000094, 0x000000a2, + 0x0000009e, 0x00000022, 0x00000022, 0x0006003d, 0x0000000a, 0x000000a3, 0x000000a2, 0x00000002, 0x00000010, 0x0003003e, + 0x000000a1, 0x000000a3, 0x0003003e, 0x000000a4, 0x0000002e, 0x00080039, 0x00000002, 0x000000a5, 0x0000001a, 0x0000009f, + 0x000000a0, 0x000000a1, 0x000000a4, 0x000200f9, 0x0000009c, 0x000200f8, 0x0000009c, 0x00050041, 0x00000091, 0x000000a6, + 0x00000090, 0x00000022, 0x0004003d, 0x0000008b, 0x000000a7, 0x000000a6, 0x00060041, 0x00000094, 0x000000a8, 0x000000a7, + 0x00000022, 0x0000003e, 0x0006003d, 0x0000000a, 0x000000a9, 0x000000a8, 0x00000002, 0x00000004, 0x00050041, 0x00000097, + 0x000000aa, 0x00000090, 0x0000004e, 0x0004003d, 0x0000000a, 0x000000ab, 0x000000aa, 0x000500ac, 0x00000006, 0x000000ac, + 0x000000a9, 0x000000ab, 0x000300f7, 0x000000ae, 0x00000000, 0x000400fa, 0x000000ac, 0x000000ad, 0x000000ae, 0x000200f8, + 0x000000ad, 0x00050041, 0x00000091, 0x000000b0, 0x00000090, 0x00000022, 0x0004003d, 0x0000008b, 0x000000b1, 0x000000b0, + 0x0003003e, 0x000000b2, 0x00000031, 0x0003003e, 0x000000b3, 0x000000af, 0x00060041, 0x00000094, 0x000000b5, 0x000000b1, + 0x00000022, 0x0000003e, 0x0006003d, 0x0000000a, 0x000000b6, 0x000000b5, 0x00000002, 0x00000004, 0x0003003e, 0x000000b4, + 0x000000b6, 0x0003003e, 0x000000b7, 0x0000002e, 0x00080039, 0x00000002, 0x000000b8, 0x0000001a, 0x000000b2, 0x000000b3, + 0x000000b4, 0x000000b7, 0x000200f9, 0x000000ae, 0x000200f8, 0x000000ae, 0x00050041, 0x00000091, 0x000000b9, 0x00000090, + 0x00000022, 0x0004003d, 0x0000008b, 0x000000ba, 0x000000b9, 0x00060041, 0x00000094, 0x000000bb, 0x000000ba, 0x00000022, + 0x0000004e, 0x0006003d, 0x0000000a, 0x000000bc, 0x000000bb, 0x00000002, 0x00000008, 0x00050041, 0x00000097, 0x000000be, + 0x00000090, 0x000000bd, 0x0004003d, 0x0000000a, 0x000000bf, 0x000000be, 0x000500ac, 0x00000006, 0x000000c0, 0x000000bc, + 0x000000bf, 0x000300f7, 0x000000c2, 0x00000000, 0x000400fa, 0x000000c0, 0x000000c1, 0x000000c2, 0x000200f8, 0x000000c1, + 0x00050041, 0x00000091, 0x000000c4, 0x00000090, 0x00000022, 0x0004003d, 0x0000008b, 0x000000c5, 0x000000c4, 0x0003003e, + 0x000000c6, 0x00000031, 0x0003003e, 0x000000c7, 0x000000c3, 0x00060041, 0x00000094, 0x000000c9, 0x000000c5, 0x00000022, + 0x0000004e, 0x0006003d, 0x0000000a, 0x000000ca, 0x000000c9, 0x00000002, 0x00000008, 0x0003003e, 0x000000c8, 0x000000ca, + 0x0003003e, 0x000000cb, 0x0000002e, 0x00080039, 0x00000002, 0x000000cc, 0x0000001a, 0x000000c6, 0x000000c7, 0x000000c8, + 0x000000cb, 0x000200f9, 0x000000c2, 0x000200f8, 0x000000c2, 0x000100fd, 0x00010038, 0x00050036, 0x00000006, 0x00000008, + 0x00000000, 0x00000007, 0x000200f8, 0x00000009, 0x00060041, 0x00000023, 0x00000024, 0x00000020, 0x00000022, 0x00000022, + 0x0004003d, 0x0000000a, 0x00000025, 0x00000024, 0x00060041, 0x00000023, 0x0000002c, 0x0000002a, 0x00000022, 0x00000025, + 0x000700ea, 0x0000000a, 0x0000002f, 0x0000002c, 0x0000002d, 0x0000002e, 0x0000002d, 0x000500ae, 0x00000006, 0x00000032, + 0x0000002f, 0x00000031, 0x000200fe, 0x00000032, 0x00010038, 0x00050036, 0x00000002, 0x00000013, 0x00000000, 0x0000000c, + 0x00030037, 0x0000000b, 0x0000000d, 0x00030037, 0x0000000b, 0x0000000e, 0x00030037, 0x0000000b, 0x0000000f, 0x00030037, + 0x0000000b, 0x00000010, 0x00030037, 0x0000000b, 0x00000011, 0x00030037, 0x0000000b, 0x00000012, 0x000200f8, 0x00000014, + 0x0004003b, 0x0000000b, 0x00000039, 0x00000007, 0x00040039, 0x00000006, 0x00000035, 0x00000008, 0x000300f7, 0x00000037, + 0x00000000, 0x000400fa, 0x00000035, 0x00000036, 0x00000037, 0x000200f8, 0x00000036, 0x000100fd, 0x000200f8, 0x00000037, + 0x00050041, 0x00000023, 0x0000003f, 0x0000003d, 0x0000003e, 0x000700ea, 0x0000000a, 0x00000041, 0x0000003f, 0x0000002d, + 0x0000002e, 0x00000040, 0x0003003e, 0x00000039, 0x00000041, 0x00050080, 0x0000000a, 0x00000045, 0x00000041, 0x00000040, + 0x00050044, 0x0000000a, 0x00000046, 0x0000003d, 0x00000002, 0x0004007c, 0x00000021, 0x00000047, 0x00000046, 0x0004007c, + 0x0000000a, 0x00000048, 0x00000047, 0x000500ac, 0x00000006, 0x00000049, 0x00000045, 0x00000048, 0x000300f7, 0x0000004c, + 0x00000000, 0x000400fa, 0x00000049, 0x0000004b, 0x0000004c, 0x000200f8, 0x0000004b, 0x000100fd, 0x000200f8, 0x0000004c, + 0x0004003d, 0x0000000a, 0x0000004f, 0x00000039, 0x00060041, 0x00000023, 0x00000051, 0x0000003d, 0x0000004e, 0x0000004f, + 0x0003003e, 0x00000051, 0x00000040, 0x00050080, 0x0000000a, 0x00000054, 0x0000004f, 0x00000053, 0x00060041, 0x00000023, + 0x00000059, 0x00000058, 0x00000022, 0x00000022, 0x0004003d, 0x0000000a, 0x0000005a, 0x00000059, 0x00060041, 0x00000023, + 0x0000005b, 0x0000003d, 0x0000004e, 0x00000054, 0x0003003e, 0x0000005b, 0x0000005a, 0x00050080, 0x0000000a, 0x0000005e, + 0x0000004f, 0x0000005d, 0x00060041, 0x00000023, 0x0000005f, 0x00000020, 0x00000022, 0x00000022, 0x0004003d, 0x0000000a, + 0x00000060, 0x0000005f, 0x00060041, 0x00000023, 0x00000061, 0x0000003d, 0x0000004e, 0x0000005e, 0x0003003e, 0x00000061, + 0x00000060, 0x00050080, 0x0000000a, 0x00000064, 0x0000004f, 0x00000063, 0x0004003d, 0x0000000a, 0x00000065, 0x0000000d, + 0x00060041, 0x00000023, 0x00000066, 0x0000003d, 0x0000004e, 0x00000064, 0x0003003e, 0x00000066, 0x00000065, 0x00050080, + 0x0000000a, 0x00000069, 0x0000004f, 0x00000068, 0x0004003d, 0x0000000a, 0x0000006a, 0x0000000e, 0x00060041, 0x00000023, + 0x0000006b, 0x0000003d, 0x0000004e, 0x00000069, 0x0003003e, 0x0000006b, 0x0000006a, 0x00050080, 0x0000000a, 0x0000006e, + 0x0000004f, 0x0000006d, 0x0004003d, 0x0000000a, 0x0000006f, 0x0000000f, 0x00060041, 0x00000023, 0x00000070, 0x0000003d, + 0x0000004e, 0x0000006e, 0x0003003e, 0x00000070, 0x0000006f, 0x00050080, 0x0000000a, 0x00000073, 0x0000004f, 0x00000072, + 0x0004003d, 0x0000000a, 0x00000074, 0x00000010, 0x00060041, 0x00000023, 0x00000075, 0x0000003d, 0x0000004e, 0x00000073, + 0x0003003e, 0x00000075, 0x00000074, 0x00050080, 0x0000000a, 0x00000078, 0x0000004f, 0x00000077, 0x0004003d, 0x0000000a, + 0x00000079, 0x00000011, 0x00060041, 0x00000023, 0x0000007a, 0x0000003d, 0x0000004e, 0x00000078, 0x0003003e, 0x0000007a, + 0x00000079, 0x00050080, 0x0000000a, 0x0000007d, 0x0000004f, 0x0000007c, 0x0004003d, 0x0000000a, 0x0000007e, 0x00000012, + 0x00060041, 0x00000023, 0x0000007f, 0x0000003d, 0x0000004e, 0x0000007d, 0x0003003e, 0x0000007f, 0x0000007e, 0x000100fd, + 0x00010038, 0x00050036, 0x00000002, 0x0000001a, 0x00000000, 0x00000015, 0x00030037, 0x0000000b, 0x00000016, 0x00030037, + 0x0000000b, 0x00000017, 0x00030037, 0x0000000b, 0x00000018, 0x00030037, 0x0000000b, 0x00000019, 0x000200f8, 0x0000001b, + 0x0004003b, 0x0000000b, 0x00000080, 0x00000007, 0x0004003b, 0x0000000b, 0x00000082, 0x00000007, 0x0004003b, 0x0000000b, + 0x00000084, 0x00000007, 0x0004003b, 0x0000000b, 0x00000086, 0x00000007, 0x0004003b, 0x0000000b, 0x00000088, 0x00000007, + 0x0004003b, 0x0000000b, 0x00000089, 0x00000007, 0x0004003d, 0x0000000a, 0x00000081, 0x00000016, 0x0003003e, 0x00000080, + 0x00000081, 0x0004003d, 0x0000000a, 0x00000083, 0x00000017, 0x0003003e, 0x00000082, 0x00000083, 0x0004003d, 0x0000000a, + 0x00000085, 0x00000018, 0x0003003e, 0x00000084, 0x00000085, 0x0004003d, 0x0000000a, 0x00000087, 0x00000019, 0x0003003e, + 0x00000086, 0x00000087, 0x0003003e, 0x00000088, 0x0000002e, 0x0003003e, 0x00000089, 0x0000002e, 0x000a0039, 0x00000002, + 0x0000008a, 0x00000013, 0x00000080, 0x00000082, 0x00000084, 0x00000086, 0x00000088, 0x00000089, 0x000100fd, 0x00010038, }; diff --git a/scripts/generate_source.py b/scripts/generate_source.py index c9d93fdb683..0caac79ad30 100755 --- a/scripts/generate_source.py +++ b/scripts/generate_source.py @@ -367,14 +367,24 @@ def main(argv): # The shaders requires glslangvalidator, so they are updated manually with generate_spirv when needed verify_exclude = [ '.clang-format', + 'cmd_validation_copy_buffer_to_image_comp.h', + 'cmd_validation_copy_buffer_to_image_comp.cpp', 'cmd_validation_dispatch_comp.h', 'cmd_validation_dispatch_comp.cpp', - 'cmd_validation_draw_vert.h', - 'cmd_validation_draw_vert.cpp', + 'cmd_validation_count_buffer_vert.h', + 'cmd_validation_count_buffer_vert.cpp', + 'cmd_validation_first_instance_vert.h', + 'cmd_validation_first_instance_vert.cpp', + 'cmd_validation_draw_indexed_vert.h', + 'cmd_validation_draw_indexed_vert.cpp', + 'cmd_validation_draw_indexed_indirect_index_buffer_vert.h', + 'cmd_validation_draw_indexed_indirect_index_buffer_vert.cpp', + 'cmd_validation_draw_indexed_indirect_vertex_buffer_vert.h', + 'cmd_validation_draw_indexed_indirect_vertex_buffer_vert.cpp', + 'cmd_validation_draw_mesh_indirect_vert.h', + 'cmd_validation_draw_mesh_indirect_vert.cpp', 'cmd_validation_trace_rays_rgen.h', 'cmd_validation_trace_rays_rgen.cpp', - 'cmd_validation_copy_buffer_to_image_comp.h', - 'cmd_validation_copy_buffer_to_image_comp.cpp', 'instrumentation_buffer_device_address_comp.h', 'instrumentation_buffer_device_address_comp.cpp', 'instrumentation_bindless_descriptor_comp.h', diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 9ae71933974..fa7b2b3b9c4 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -105,6 +105,7 @@ target_sources(vk_layer_validation_tests PRIVATE unit/gpu_av_descriptor_indexing.cpp unit/gpu_av_descriptor_indexing_positive.cpp unit/gpu_av_indirect_buffer.cpp + unit/gpu_av_index_buffer_positive.cpp unit/gpu_av_oob.cpp unit/gpu_av_oob_positive.cpp unit/gpu_av_positive.cpp diff --git a/tests/framework/buffer_helper.h b/tests/framework/buffer_helper.h index adc7f10663d..61d022bbe85 100644 --- a/tests/framework/buffer_helper.h +++ b/tests/framework/buffer_helper.h @@ -42,4 +42,15 @@ Buffer IndexBuffer(const Device &dev, const std::vector &indices) { return index_buffer; } -} // namespace vkt \ No newline at end of file +// stride == sizeof(IndirectCmdT) +template +Buffer IndirectBuffer(const Device &dev, const std::vector &indirect_cmds) { + vkt::Buffer indirect_buffer(dev, indirect_cmds.size() * sizeof(IndirectCmdT), VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); + auto *indirect_buffer_ptr = static_cast(indirect_buffer.memory().map()); + std::copy(indirect_cmds.data(), indirect_cmds.data() + indirect_cmds.size(), indirect_buffer_ptr); + indirect_buffer.memory().unmap(); + return indirect_buffer; +} + +} // namespace vkt diff --git a/tests/unit/gpu_av_index_buffer_positive.cpp b/tests/unit/gpu_av_index_buffer_positive.cpp new file mode 100644 index 00000000000..4738892dd14 --- /dev/null +++ b/tests/unit/gpu_av_index_buffer_positive.cpp @@ -0,0 +1,180 @@ +/* + * Copyright (c) 2020-2024 The Khronos Group Inc. + * Copyright (c) 2020-2024 Valve Corporation + * Copyright (c) 2020-2024 LunarG, Inc. + * Copyright (c) 2020-2024 Google, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + */ + +#include "../framework/layer_validation_tests.h" +#include "../framework/pipeline_helper.h" +#include "../framework/buffer_helper.h" + +class PositiveGpuAVIndexBuffer : public GpuAVTest {}; + +TEST_F(PositiveGpuAVIndexBuffer, BadVertexIndex) { + TEST_DESCRIPTION("If no vertex buffer is used, all index values are legal"); + AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + RETURN_IF_SKIP(InitGpuAvFramework()); + + AddDisabledFeature(vkt::Feature::drawIndirectFirstInstance); + RETURN_IF_SKIP(InitState(nullptr)); + InitRenderTarget(); + + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vku::InitStructHelper(); + vkt::PipelineLayout pipeline_layout(*m_device, pipelineLayoutCreateInfo); + + CreatePipelineHelper pipe(*this); + pipe.gp_ci_.layout = pipeline_layout.handle(); + pipe.CreateGraphicsPipeline(); + + VkDrawIndexedIndirectCommand draw_params{}; + draw_params.indexCount = 3; + draw_params.instanceCount = 1; + draw_params.firstIndex = 0; + draw_params.vertexOffset = 0; + draw_params.firstInstance = 0; + vkt::Buffer draw_params_buffer = vkt::IndirectBuffer(*m_device, {draw_params}); + + VkCommandBufferBeginInfo begin_info = vku::InitStructHelper(); + m_commandBuffer->begin(&begin_info); + m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); + vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); + vkt::Buffer index_buffer = vkt::IndexBuffer(*m_device, {0, std::numeric_limits::max(), 42}); + + vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32); + vk::CmdDrawIndexedIndirect(m_commandBuffer->handle(), draw_params_buffer.handle(), 0, 1, sizeof(VkDrawIndexedIndirectCommand)); + m_commandBuffer->EndRenderPass(); + m_commandBuffer->end(); + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); +} + +TEST_F(PositiveGpuAVIndexBuffer, VertexIndex) { + TEST_DESCRIPTION("Validate index buffer values"); + AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + RETURN_IF_SKIP(InitGpuAvFramework()); + + AddDisabledFeature(vkt::Feature::drawIndirectFirstInstance); + RETURN_IF_SKIP(InitState()); + InitRenderTarget(); + + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vku::InitStructHelper(); + vkt::PipelineLayout pipeline_layout(*m_device, pipelineLayoutCreateInfo); + + CreatePipelineHelper pipe(*this); + pipe.gp_ci_.layout = pipeline_layout.handle(); + pipe.CreateGraphicsPipeline(); + + constexpr uint32_t num_vertices = 12; + std::vector indicies(num_vertices); + for (uint32_t i = 0; i < num_vertices; i++) { + indicies[i] = num_vertices - 1 - i; + } + vkt::Buffer index_buffer = vkt::IndexBuffer(*m_device, std::move(indicies)); + + VkDrawIndexedIndirectCommand draw_params{}; + draw_params.indexCount = 3; + draw_params.instanceCount = 1; + draw_params.firstIndex = 0; + draw_params.vertexOffset = 0; + draw_params.firstInstance = 0; + vkt::Buffer draw_params_buffer = vkt::IndirectBuffer(*m_device, {draw_params}); + + VkCommandBufferBeginInfo begin_info = vku::InitStructHelper(); + m_commandBuffer->begin(&begin_info); + m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); + vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); + + vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32); + vk::CmdDrawIndexedIndirect(m_commandBuffer->handle(), draw_params_buffer.handle(), 0, 1, sizeof(VkDrawIndexedIndirectCommand)); + m_commandBuffer->EndRenderPass(); + m_commandBuffer->end(); + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); +} + +TEST_F(PositiveGpuAVIndexBuffer, DrawIndexedDynamicStates) { + TEST_DESCRIPTION("vkCmdDrawIndexed - Set dynamic states"); + AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + AddRequiredExtensions(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME); + AddRequiredExtensions(VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME); + AddRequiredExtensions(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME); + RETURN_IF_SKIP(InitGpuAvFramework()); + + AddRequiredFeature(vkt::Feature::extendedDynamicState); + AddRequiredFeature(vkt::Feature::extendedDynamicState2); + AddRequiredFeature(vkt::Feature::extendedDynamicState3PolygonMode); + AddDisabledFeature(vkt::Feature::robustBufferAccess); + RETURN_IF_SKIP(InitState()); + InitRenderTarget(); + + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vku::InitStructHelper(); + vkt::PipelineLayout pipeline_layout(*m_device, pipelineLayoutCreateInfo); + + char const *vsSource = R"glsl( + #version 450 + + layout(location=0) in vec3 pos; + + void main() { + gl_Position = vec4(pos, 1.0); + } + )glsl"; + VkShaderObj vs(this, vsSource, VK_SHADER_STAGE_VERTEX_BIT); + + CreatePipelineHelper pipe(*this); + VkVertexInputBindingDescription input_binding = {0, 3 * sizeof(float), VK_VERTEX_INPUT_RATE_VERTEX}; + VkVertexInputAttributeDescription input_attrib = {0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0}; + pipe.vi_ci_.pVertexBindingDescriptions = &input_binding; + pipe.vi_ci_.vertexBindingDescriptionCount = 1; + pipe.vi_ci_.pVertexAttributeDescriptions = &input_attrib; + pipe.vi_ci_.vertexAttributeDescriptionCount = 1; + pipe.gp_ci_.layout = pipeline_layout.handle(); + pipe.shader_stages_ = {vs.GetStageCreateInfo(), pipe.fs_->GetStageCreateInfo()}; + pipe.AddDynamicState(VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE); + pipe.AddDynamicState(VK_DYNAMIC_STATE_CULL_MODE); + pipe.AddDynamicState(VK_DYNAMIC_STATE_FRONT_FACE); + pipe.AddDynamicState(VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE); + pipe.AddDynamicState(VK_DYNAMIC_STATE_DEPTH_BIAS); + pipe.AddDynamicState(VK_DYNAMIC_STATE_LINE_WIDTH); + pipe.AddDynamicState(VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE); + pipe.AddDynamicState(VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY); + pipe.CreateGraphicsPipeline(); + + vkt::Buffer index_buffer = vkt::IndexBuffer(*m_device, {0, 1, 2}); + vkt::Buffer vertex_buffer = vkt::VertexBuffer(*m_device, {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}); + VkDeviceSize vertex_buffer_offset = 0; + + VkCommandBufferBeginInfo begin_info = vku::InitStructHelper(); + m_commandBuffer->begin(&begin_info); + m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); + + vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); + + vk::CmdSetRasterizerDiscardEnableEXT(m_commandBuffer->handle(), VK_FALSE); + vk::CmdSetCullModeEXT(m_commandBuffer->handle(), VK_CULL_MODE_NONE); + vk::CmdSetFrontFaceEXT(m_commandBuffer->handle(), VK_FRONT_FACE_CLOCKWISE); + vk::CmdSetDepthBiasEnableEXT(m_commandBuffer->handle(), VK_TRUE); + vk::CmdSetDepthBias(m_commandBuffer->handle(), 0.0f, 1.0f, 1.0f); + vk::CmdSetLineWidth(m_commandBuffer->handle(), 1.0f); + vk::CmdSetPrimitiveRestartEnableEXT(m_commandBuffer->handle(), VK_FALSE); + vk::CmdSetPrimitiveTopologyEXT(m_commandBuffer->handle(), VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST); + + vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32); + vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vertex_buffer.handle(), &vertex_buffer_offset); + + vk::CmdDrawIndexed(m_commandBuffer->handle(), 3, 1, 0, 0, 0); + + m_commandBuffer->EndRenderPass(); + m_commandBuffer->end(); + + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); + m_errorMonitor->VerifyFound(); +} diff --git a/tests/unit/gpu_av_indirect_buffer.cpp b/tests/unit/gpu_av_indirect_buffer.cpp index 6982055bcf8..880c09d9137 100644 --- a/tests/unit/gpu_av_indirect_buffer.cpp +++ b/tests/unit/gpu_av_indirect_buffer.cpp @@ -13,6 +13,7 @@ #include "../framework/layer_validation_tests.h" #include "../framework/pipeline_helper.h" +#include "../framework/buffer_helper.h" class NegativeGpuAVIndirectBuffer : public GpuAVTest {}; @@ -241,9 +242,6 @@ TEST_F(NegativeGpuAVIndirectBuffer, DrawCount) { pipe.gp_ci_.layout = pipeline_layout.handle(); pipe.CreateGraphicsPipeline(); - m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndirectCount-countBuffer-03122", - "Indirect draw count of 2 would exceed buffer size 16 of buffer .* stride = 16 offset = 0 " - ".* = 36"); uint32_t *count_ptr = static_cast(count_buffer.memory().map()); *count_ptr = 2; count_buffer.memory().unmap(); @@ -251,7 +249,9 @@ TEST_F(NegativeGpuAVIndirectBuffer, DrawCount) { m_commandBuffer->begin(&begin_info); m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); - + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndirectCount-countBuffer-03122", + "Indirect draw count of 2 would exceed size \\(16\\) of buffer .* stride = 16 offset = 0 " + ".* = 32"); vk::CmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), 0, 1, sizeof(VkDrawIndirectCommand)); m_commandBuffer->EndRenderPass(); @@ -259,15 +259,18 @@ TEST_F(NegativeGpuAVIndirectBuffer, DrawCount) { m_default_queue->Submit(*m_commandBuffer); m_default_queue->Wait(); m_errorMonitor->VerifyFound(); + count_ptr = static_cast(count_buffer.memory().map()); *count_ptr = 1; count_buffer.memory().unmap(); - m_errorMonitor->SetDesiredError("VUID-vkCmdDrawIndirectCount-countBuffer-03121"); m_commandBuffer->begin(); m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); // Offset of 4 should error + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndirectCount-countBuffer-03122", + "Indirect draw count of 1 would exceed size \\(16\\) of buffer .* stride = 16 offset = 4 " + ".* = 20"); vk::CmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 4, count_buffer.handle(), 0, 1, sizeof(VkDrawIndirectCommand)); m_commandBuffer->EndRenderPass(); @@ -276,7 +279,6 @@ TEST_F(NegativeGpuAVIndirectBuffer, DrawCount) { m_default_queue->Wait(); m_errorMonitor->VerifyFound(); - m_errorMonitor->SetDesiredError("VUID-vkCmdDrawIndexedIndirectCount-countBuffer-03154"); vkt::Buffer indexed_draw_buffer(*m_device, sizeof(VkDrawIndexedIndirectCommand), VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); VkDrawIndexedIndirectCommand *indexed_draw_ptr = (VkDrawIndexedIndirectCommand *)indexed_draw_buffer.memory().map(); @@ -295,6 +297,10 @@ TEST_F(NegativeGpuAVIndirectBuffer, DrawCount) { vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); vkt::Buffer index_buffer(*m_device, 3 * sizeof(uint32_t), VK_BUFFER_USAGE_INDEX_BUFFER_BIT); vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32); + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexedIndirectCount-countBuffer-03154", + "Indirect draw count of 2 would exceed size \\(20\\) of buffer .* stride = 20 offset = 0 " + ".* = 40"); + vk::CmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), indexed_draw_buffer.handle(), 0, count_buffer.handle(), 0, 1, sizeof(VkDrawIndexedIndirectCommand)); m_commandBuffer->EndRenderPass(); @@ -302,16 +308,19 @@ TEST_F(NegativeGpuAVIndirectBuffer, DrawCount) { m_default_queue->Submit(*m_commandBuffer); m_default_queue->Wait(); m_errorMonitor->VerifyFound(); + count_ptr = static_cast(count_buffer.memory().map()); *count_ptr = 1; count_buffer.memory().unmap(); - m_errorMonitor->SetDesiredError("VUID-vkCmdDrawIndexedIndirectCount-countBuffer-03153"); m_commandBuffer->begin(&begin_info); m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32); // Offset of 4 should error + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexedIndirectCount-countBuffer-03154", + "Indirect draw count of 1 would exceed size \\(20\\) of buffer .* stride = 20 offset = 4 " + ".* = 24"); vk::CmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), indexed_draw_buffer.handle(), 4, count_buffer.handle(), 0, 1, sizeof(VkDrawIndexedIndirectCommand)); m_commandBuffer->EndRenderPass(); @@ -335,7 +344,7 @@ TEST_F(NegativeGpuAVIndirectBuffer, DrawCount) { CreatePipelineHelper mesh_pipe(*this); mesh_pipe.shader_stages_[0] = mesh_shader.GetStageCreateInfo(); mesh_pipe.CreateGraphicsPipeline(); - vkt::Buffer mesh_draw_buffer(*m_device, sizeof(VkDrawIndirectCommand), VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, + vkt::Buffer mesh_draw_buffer(*m_device, sizeof(VkDrawMeshTasksIndirectCommandEXT), VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); VkDrawMeshTasksIndirectCommandEXT *mesh_draw_ptr = @@ -344,7 +353,10 @@ TEST_F(NegativeGpuAVIndirectBuffer, DrawCount) { mesh_draw_ptr->groupCountY = 0; mesh_draw_ptr->groupCountZ = 0; mesh_draw_buffer.memory().unmap(); - m_errorMonitor->SetDesiredError("VUID-vkCmdDrawMeshTasksIndirectCountEXT-countBuffer-07098"); + m_errorMonitor->SetDesiredErrorRegex( + "VUID-vkCmdDrawMeshTasksIndirectCountEXT-countBuffer-07099", + "Indirect draw count of 1 would exceed size \\(12\\) of buffer .* stride = 12 offset = 8 " + ".* = 20"); count_ptr = static_cast(count_buffer.memory().map()); *count_ptr = 1; count_buffer.memory().unmap(); @@ -359,7 +371,10 @@ TEST_F(NegativeGpuAVIndirectBuffer, DrawCount) { m_default_queue->Wait(); m_errorMonitor->VerifyFound(); - m_errorMonitor->SetDesiredError("VUID-vkCmdDrawMeshTasksIndirectCountEXT-countBuffer-07099"); + m_errorMonitor->SetDesiredErrorRegex( + "VUID-vkCmdDrawMeshTasksIndirectCountEXT-countBuffer-07099", + "Indirect draw count of 2 would exceed size \\(12\\) of buffer .* stride = 12 offset = 4 " + ".* = 28"); count_ptr = static_cast(count_buffer.memory().map()); *count_ptr = 2; count_buffer.memory().unmap(); @@ -381,16 +396,14 @@ TEST_F(NegativeGpuAVIndirectBuffer, Mesh) { SetTargetApiVersion(VK_API_VERSION_1_3); AddRequiredExtensions(VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME); AddRequiredExtensions(VK_EXT_MESH_SHADER_EXTENSION_NAME); + AddRequiredFeature(vkt::Feature::meshShader); + AddRequiredFeature(vkt::Feature::taskShader); + AddRequiredFeature(vkt::Feature::maintenance4); + AddDisabledFeature(vkt::Feature::multiviewMeshShader); + AddDisabledFeature(vkt::Feature::primitiveFragmentShadingRateMeshShader); RETURN_IF_SKIP(InitGpuAvFramework()); - VkPhysicalDeviceMeshShaderFeaturesEXT mesh_shader_features = vku::InitStructHelper(); - VkPhysicalDeviceVulkan13Features features13 = vku::InitStructHelper(&mesh_shader_features); - - GetPhysicalDeviceFeatures2(features13); - mesh_shader_features.multiviewMeshShader = VK_FALSE; - mesh_shader_features.primitiveFragmentShadingRateMeshShader = VK_FALSE; - - RETURN_IF_SKIP(InitState(nullptr, &features13)); + RETURN_IF_SKIP(InitState()); InitRenderTarget(); VkPhysicalDeviceMeshShaderPropertiesEXT mesh_shader_props = vku::InitStructHelper(); GetPhysicalDeviceProperties2(mesh_shader_props); @@ -426,54 +439,67 @@ TEST_F(NegativeGpuAVIndirectBuffer, Mesh) { CreatePipelineHelper mesh_pipe(*this); mesh_pipe.shader_stages_[0] = mesh_shader.GetStageCreateInfo(); mesh_pipe.CreateGraphicsPipeline(); - // 012 456 8910 + // Set x in third draw - draw_ptr[8] = mesh_shader_props.maxMeshWorkGroupCount[0] + 1; VkCommandBufferBeginInfo begin_info = vku::InitStructHelper(); m_commandBuffer->begin(&begin_info); m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, mesh_pipe.Handle()); - m_errorMonitor->SetDesiredError("VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07326"); + vk::CmdDrawMeshTasksIndirectEXT(m_commandBuffer->handle(), draw_buffer.handle(), 0, 3, (sizeof(VkDrawMeshTasksIndirectCommandEXT) + 4)); m_commandBuffer->EndRenderPass(); m_commandBuffer->end(); - m_default_queue->Submit(*m_commandBuffer); - m_default_queue->Wait(); - m_errorMonitor->VerifyFound(); + + if (mesh_shader_props.maxMeshWorkGroupCount[0] < std::numeric_limits::max()) { + m_errorMonitor->SetDesiredError("VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07326"); + draw_ptr[8] = mesh_shader_props.maxMeshWorkGroupCount[0] + 1; + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); + m_errorMonitor->VerifyFound(); + draw_ptr[8] = 0; + } // Set y in second draw - draw_ptr[8] = 0; - draw_ptr[5] = mesh_shader_props.maxMeshWorkGroupCount[1] + 1; - m_errorMonitor->SetDesiredError("VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07327"); - m_default_queue->Submit(*m_commandBuffer); - m_default_queue->Wait(); - m_errorMonitor->VerifyFound(); + if (mesh_shader_props.maxMeshWorkGroupCount[1] < std::numeric_limits::max()) { + draw_ptr[5] = mesh_shader_props.maxMeshWorkGroupCount[1] + 1; + m_errorMonitor->SetDesiredError("VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07327"); + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); + m_errorMonitor->VerifyFound(); + draw_ptr[5] = 0; + } // Set z in first draw - draw_ptr[5] = 0; - draw_ptr[2] = mesh_shader_props.maxMeshWorkGroupCount[2] + 1; - m_errorMonitor->SetDesiredError("VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07328"); - m_default_queue->Submit(*m_commandBuffer); - m_default_queue->Wait(); - m_errorMonitor->VerifyFound(); - draw_ptr[2] = 0; - - uint32_t half_total = (mesh_shader_props.maxMeshWorkGroupTotalCount + 2) / 2; - if (half_total < mesh_shader_props.maxMeshWorkGroupCount[0]) { - draw_ptr[2] = 1; - draw_ptr[1] = 2; - draw_ptr[0] = (mesh_shader_props.maxMeshWorkGroupTotalCount + 2) / 2; - - m_errorMonitor->SetDesiredError("VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07329"); + if (mesh_shader_props.maxMeshWorkGroupCount[2] < std::numeric_limits::max()) { + draw_ptr[2] = mesh_shader_props.maxMeshWorkGroupCount[2] + 1; + m_errorMonitor->SetDesiredError("VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07328"); m_default_queue->Submit(*m_commandBuffer); m_default_queue->Wait(); m_errorMonitor->VerifyFound(); - draw_ptr[2] = 0; - draw_ptr[1] = 0; - draw_ptr[0] = 0; } +// total count can end up being really high, draw takes too long and times out +#if 0 + if (mesh_shader_props.maxMeshWorkGroupTotalCount < std::numeric_limits::max()) { + const uint32_t half_total = (mesh_shader_props.maxMeshWorkGroupTotalCount + 2) / 2; + if (half_total < mesh_shader_props.maxMeshWorkGroupCount[0]) { + draw_ptr[2] = 1; + draw_ptr[1] = 2; + draw_ptr[0] = (mesh_shader_props.maxMeshWorkGroupTotalCount + 2) / 2; + + m_errorMonitor->SetDesiredError("VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07329"); + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); + m_errorMonitor->VerifyFound(); + + draw_ptr[2] = 0; + draw_ptr[1] = 0; + draw_ptr[0] = 0; + } + } +#endif + memset(draw_ptr, 0, buffer_size); char const *task_shader_source = R"glsl( #version 450 @@ -497,115 +523,776 @@ TEST_F(NegativeGpuAVIndirectBuffer, Mesh) { m_commandBuffer->end(); // Set x in second draw - draw_ptr[4] = mesh_shader_props.maxTaskWorkGroupCount[0] + 1; - m_errorMonitor->SetDesiredError("VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07322"); + if (mesh_shader_props.maxTaskWorkGroupCount[0] < std::numeric_limits::max()) { + draw_ptr[4] = mesh_shader_props.maxTaskWorkGroupCount[0] + 1; + m_errorMonitor->SetDesiredError("VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07322"); + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); + m_errorMonitor->VerifyFound(); + draw_ptr[4] = 0; + } + + // Set y in first draw + if (mesh_shader_props.maxTaskWorkGroupCount[1] < std::numeric_limits::max()) { + draw_ptr[1] = mesh_shader_props.maxTaskWorkGroupCount[1] + 1; + m_errorMonitor->SetDesiredError("VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07323"); + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); + m_errorMonitor->VerifyFound(); + draw_ptr[1] = 0; + } + + // Set z in third draw + if (mesh_shader_props.maxTaskWorkGroupCount[2] < std::numeric_limits::max()) { + draw_ptr[10] = mesh_shader_props.maxTaskWorkGroupCount[2] + 1; + m_errorMonitor->SetDesiredError("VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07324"); + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); + m_errorMonitor->VerifyFound(); + draw_ptr[10] = 0; + } + + if (mesh_shader_props.maxTaskWorkGroupTotalCount < std::numeric_limits::max()) { + const uint32_t half_total = (mesh_shader_props.maxTaskWorkGroupTotalCount + 2) / 2; + if (half_total < mesh_shader_props.maxTaskWorkGroupCount[0]) { + draw_ptr[2] = 1; + draw_ptr[1] = 2; + draw_ptr[0] = (mesh_shader_props.maxTaskWorkGroupTotalCount + 2) / 2; + + m_errorMonitor->SetDesiredError("VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07325"); + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); + m_errorMonitor->VerifyFound(); + + draw_ptr[2] = 0; + draw_ptr[1] = 0; + draw_ptr[0] = 0; + } + } + draw_buffer.memory().unmap(); +} + +TEST_F(NegativeGpuAVIndirectBuffer, FirstInstance) { + TEST_DESCRIPTION("Validate illegal firstInstance values"); + AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + RETURN_IF_SKIP(InitGpuAvFramework()); + + AddDisabledFeature(vkt::Feature::drawIndirectFirstInstance); + RETURN_IF_SKIP(InitState()); + InitRenderTarget(); + + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vku::InitStructHelper(); + vkt::PipelineLayout pipeline_layout(*m_device, pipelineLayoutCreateInfo); + + CreatePipelineHelper pipe(*this); + pipe.gp_ci_.layout = pipeline_layout.handle(); + pipe.CreateGraphicsPipeline(); + + VkDrawIndirectCommand draw_params{}; + draw_params.vertexCount = 3; + draw_params.instanceCount = 1; + draw_params.firstVertex = 0; + draw_params.firstInstance = 0; + VkDrawIndirectCommand draw_params_invalid_first_instance_1 = draw_params; + draw_params_invalid_first_instance_1.firstInstance = 1; + VkDrawIndirectCommand draw_params_invalid_first_instance_42 = draw_params; + draw_params_invalid_first_instance_42.firstInstance = 42; + vkt::Buffer draw_params_buffer = vkt::IndirectBuffer( + *m_device, {draw_params, draw_params_invalid_first_instance_1, draw_params, draw_params_invalid_first_instance_42}); + + VkCommandBufferBeginInfo begin_info = vku::InitStructHelper(); + m_commandBuffer->begin(&begin_info); + m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); + vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); + + m_errorMonitor->SetDesiredErrorRegex("VUID-VkDrawIndirectCommand-firstInstance-00501", "at index 1 is 1"); + m_errorMonitor->SetDesiredErrorRegex("VUID-VkDrawIndirectCommand-firstInstance-00501", "at index 3 is 42"); + vk::CmdDrawIndirect(m_commandBuffer->handle(), draw_params_buffer.handle(), 0, 4, sizeof(VkDrawIndirectCommand)); + + m_commandBuffer->EndRenderPass(); + m_commandBuffer->end(); + m_default_queue->Submit(*m_commandBuffer); m_default_queue->Wait(); m_errorMonitor->VerifyFound(); - draw_ptr[4] = 0; +} - // Set y in first draw - draw_ptr[1] = mesh_shader_props.maxTaskWorkGroupCount[0] + 1; - m_errorMonitor->SetDesiredError("VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07323"); +TEST_F(NegativeGpuAVIndirectBuffer, FirstInstanceIndexed) { + TEST_DESCRIPTION("Validate illegal firstInstance values"); + AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + RETURN_IF_SKIP(InitGpuAvFramework()); + + AddDisabledFeature(vkt::Feature::drawIndirectFirstInstance); + RETURN_IF_SKIP(InitState()); + InitRenderTarget(); + + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vku::InitStructHelper(); + vkt::PipelineLayout pipeline_layout(*m_device, pipelineLayoutCreateInfo); + + CreatePipelineHelper pipe(*this); + pipe.gp_ci_.layout = pipeline_layout.handle(); + pipe.CreateGraphicsPipeline(); + + VkDrawIndexedIndirectCommand draw_params{}; + draw_params.indexCount = 3; + draw_params.instanceCount = 1; + draw_params.firstIndex = 0; + draw_params.vertexOffset = 0; + draw_params.firstInstance = 0; + VkDrawIndexedIndirectCommand draw_params_invalid_first_instance = draw_params; + draw_params_invalid_first_instance.firstInstance = 1; + vkt::Buffer draw_params_buffer = vkt::IndirectBuffer( + *m_device, {draw_params, draw_params, draw_params, draw_params_invalid_first_instance}); + + vkt::Buffer index_buffer = vkt::IndexBuffer(*m_device, {1, 2, 3}); + + VkCommandBufferBeginInfo begin_info = vku::InitStructHelper(); + m_commandBuffer->begin(&begin_info); + m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); + vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); + + vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32); + m_errorMonitor->SetDesiredErrorRegex("VUID-VkDrawIndexedIndirectCommand-firstInstance-00554", "at index 2 is 1"); + vk::CmdDrawIndexedIndirect(m_commandBuffer->handle(), draw_params_buffer.handle(), sizeof(VkDrawIndexedIndirectCommand), 3, + sizeof(VkDrawIndexedIndirectCommand)); + m_commandBuffer->EndRenderPass(); + m_commandBuffer->end(); m_default_queue->Submit(*m_commandBuffer); m_default_queue->Wait(); m_errorMonitor->VerifyFound(); - draw_ptr[1] = 0; +} - // Set z in third draw - draw_ptr[10] = mesh_shader_props.maxTaskWorkGroupCount[0] + 1; - m_errorMonitor->SetDesiredError("VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07324"); +TEST_F(NegativeGpuAVIndirectBuffer, IndexBufferOOB) { + TEST_DESCRIPTION("Validate overruning the index buffer"); + AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + RETURN_IF_SKIP(InitGpuAvFramework()); + + AddDisabledFeature(vkt::Feature::drawIndirectFirstInstance); + AddDisabledFeature(vkt::Feature::robustBufferAccess); + RETURN_IF_SKIP(InitState()); + InitRenderTarget(); + + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vku::InitStructHelper(); + vkt::PipelineLayout pipeline_layout(*m_device, pipelineLayoutCreateInfo); + + CreatePipelineHelper pipe(*this); + pipe.gp_ci_.layout = pipeline_layout.handle(); + pipe.CreateGraphicsPipeline(); + + VkDrawIndexedIndirectCommand draw_params{}; + draw_params.indexCount = 3; + draw_params.instanceCount = 1; + draw_params.firstIndex = 1; + draw_params.vertexOffset = 0; + draw_params.firstInstance = 0; + vkt::Buffer draw_params_buffer = vkt::IndirectBuffer(*m_device, {draw_params}); + + vkt::Buffer index_buffer = vkt::IndexBuffer(*m_device, {1, 2, 3}); + + VkCommandBufferBeginInfo begin_info = vku::InitStructHelper(); + m_commandBuffer->begin(&begin_info); + m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); + vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); + + m_errorMonitor->SetDesiredErrorRegex( + "VUID-VkDrawIndexedIndirectCommand-robustBufferAccess2-08798", + "Index 4 is not within the bound index buffer. Computed from VkDrawIndexedIndirectCommand\\[0\\]"); + vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32); + vk::CmdDrawIndexedIndirect(m_commandBuffer->handle(), draw_params_buffer.handle(), 0, 1, sizeof(VkDrawIndexedIndirectCommand)); + m_commandBuffer->EndRenderPass(); + m_commandBuffer->end(); m_default_queue->Submit(*m_commandBuffer); m_default_queue->Wait(); m_errorMonitor->VerifyFound(); - draw_ptr[10] = 0; +} - half_total = (mesh_shader_props.maxTaskWorkGroupTotalCount + 2) / 2; - if (half_total < mesh_shader_props.maxTaskWorkGroupCount[0]) { - draw_ptr[2] = 1; - draw_ptr[1] = 2; - draw_ptr[0] = (mesh_shader_props.maxTaskWorkGroupTotalCount + 2) / 2; +TEST_F(NegativeGpuAVIndirectBuffer, IndirectDrawBadVertexIndex32) { + TEST_DESCRIPTION("Validate illegal index buffer values - uint32_t index"); + AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + RETURN_IF_SKIP(InitGpuAvFramework()); - m_errorMonitor->SetDesiredError("VUID-VkDrawMeshTasksIndirectCommandEXT-TaskEXT-07325"); - m_default_queue->Submit(*m_commandBuffer); - m_default_queue->Wait(); - m_errorMonitor->VerifyFound(); + AddDisabledFeature(vkt::Feature::drawIndirectFirstInstance); + AddDisabledFeature(vkt::Feature::robustBufferAccess); + RETURN_IF_SKIP(InitState()); + InitRenderTarget(); - draw_ptr[2] = 0; - draw_ptr[1] = 0; - draw_ptr[0] = 0; - } - draw_buffer.memory().unmap(); + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vku::InitStructHelper(); + vkt::PipelineLayout pipeline_layout(*m_device, pipelineLayoutCreateInfo); + + char const *vsSource = R"glsl( + #version 450 + + layout(location=0) in vec3 pos; + + void main() { + gl_Position = vec4(pos, 1.0); + } +)glsl"; + VkShaderObj vs(this, vsSource, VK_SHADER_STAGE_VERTEX_BIT); + + CreatePipelineHelper pipe(*this); + VkVertexInputBindingDescription input_binding = {0, 3 * sizeof(float), VK_VERTEX_INPUT_RATE_VERTEX}; + VkVertexInputAttributeDescription input_attrib = {0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0}; + pipe.vi_ci_.pVertexBindingDescriptions = &input_binding; + pipe.vi_ci_.vertexBindingDescriptionCount = 1; + pipe.vi_ci_.pVertexAttributeDescriptions = &input_attrib; + pipe.vi_ci_.vertexAttributeDescriptionCount = 1; + pipe.gp_ci_.layout = pipeline_layout.handle(); + pipe.shader_stages_ = {vs.GetStageCreateInfo(), pipe.fs_->GetStageCreateInfo()}; + + pipe.CreateGraphicsPipeline(); + + VkDrawIndexedIndirectCommand draw_params{}; + draw_params.indexCount = 3; + draw_params.instanceCount = 1; + draw_params.firstIndex = 0; + draw_params.vertexOffset = 0; + draw_params.firstInstance = 0; + vkt::Buffer draw_params_buffer = vkt::IndirectBuffer(*m_device, {draw_params}); + + VkCommandBufferBeginInfo begin_info = vku::InitStructHelper(); + m_commandBuffer->begin(&begin_info); + m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); + + vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); + + vkt::Buffer index_buffer = vkt::IndexBuffer(*m_device, {0, 666, 42}); + vkt::Buffer vertex_buffer = vkt::VertexBuffer(*m_device, {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}); + VkDeviceSize vertex_buffer_offset = 0; + vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32); + vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vertex_buffer.handle(), &vertex_buffer_offset); + + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexedIndirect-None-02721", "Vertex index 666"); + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexedIndirect-None-02721", "Vertex index 42"); + vk::CmdDrawIndexedIndirect(m_commandBuffer->handle(), draw_params_buffer.handle(), 0, 1, sizeof(VkDrawIndexedIndirectCommand)); + + m_commandBuffer->EndRenderPass(); + m_commandBuffer->end(); + + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); + m_errorMonitor->VerifyFound(); } -TEST_F(NegativeGpuAVIndirectBuffer, FirstInstance) { - TEST_DESCRIPTION("Validate illegal firstInstance values"); +TEST_F(NegativeGpuAVIndirectBuffer, IndirectDrawBadVertexIndex16) { + TEST_DESCRIPTION("Validate illegal index buffer values - uint16_t index"); AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); RETURN_IF_SKIP(InitGpuAvFramework()); AddDisabledFeature(vkt::Feature::drawIndirectFirstInstance); - RETURN_IF_SKIP(InitState(nullptr)); + AddDisabledFeature(vkt::Feature::robustBufferAccess); + + RETURN_IF_SKIP(InitState()); InitRenderTarget(); - vkt::Buffer draw_buffer(*m_device, 4 * sizeof(VkDrawIndirectCommand), VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); - VkDrawIndirectCommand *draw_ptr = static_cast(draw_buffer.memory().map()); - for (uint32_t i = 0; i < 4; i++) { - draw_ptr->vertexCount = 3; - draw_ptr->instanceCount = 1; - draw_ptr->firstVertex = 0; - draw_ptr->firstInstance = (i == 3) ? 1 : 0; - draw_ptr++; - } - draw_buffer.memory().unmap(); + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vku::InitStructHelper(); + vkt::PipelineLayout pipeline_layout(*m_device, pipelineLayoutCreateInfo); + + char const *vsSource = R"glsl( + #version 450 + + layout(location=0) in vec3 pos; + + void main() { + gl_Position = vec4(pos, 1.0); + } + )glsl"; + VkShaderObj vs(this, vsSource, VK_SHADER_STAGE_VERTEX_BIT); + + CreatePipelineHelper pipe(*this); + VkVertexInputBindingDescription input_binding = {0, 3 * sizeof(float), VK_VERTEX_INPUT_RATE_VERTEX}; + VkVertexInputAttributeDescription input_attrib = {0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0}; + pipe.vi_ci_.pVertexBindingDescriptions = &input_binding; + pipe.vi_ci_.vertexBindingDescriptionCount = 1; + pipe.vi_ci_.pVertexAttributeDescriptions = &input_attrib; + pipe.vi_ci_.vertexAttributeDescriptionCount = 1; + pipe.gp_ci_.layout = pipeline_layout.handle(); + pipe.shader_stages_ = {vs.GetStageCreateInfo(), pipe.fs_->GetStageCreateInfo()}; + + pipe.CreateGraphicsPipeline(); + + VkDrawIndexedIndirectCommand draw_params{}; + draw_params.indexCount = 3; + draw_params.instanceCount = 1; + draw_params.firstIndex = 0; + draw_params.vertexOffset = 0; + draw_params.firstInstance = 0; + vkt::Buffer draw_params_buffer = vkt::IndirectBuffer(*m_device, {draw_params}); + + VkCommandBufferBeginInfo begin_info = vku::InitStructHelper(); + m_commandBuffer->begin(&begin_info); + m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); + + vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); + + vkt::Buffer index_buffer = vkt::IndexBuffer(*m_device, {0, 128, 42}); + vkt::Buffer vertex_buffer = vkt::VertexBuffer(*m_device, {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}); + VkDeviceSize vertex_buffer_offset = 0; + vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT16); + vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vertex_buffer.handle(), &vertex_buffer_offset); + + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexedIndirect-None-02721", "Vertex index 128"); + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexedIndirect-None-02721", "Vertex index 42"); + vk::CmdDrawIndexedIndirect(m_commandBuffer->handle(), draw_params_buffer.handle(), 0, 1, sizeof(VkDrawIndexedIndirectCommand)); + + m_commandBuffer->EndRenderPass(); + m_commandBuffer->end(); + + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); + m_errorMonitor->VerifyFound(); +} + +TEST_F(NegativeGpuAVIndirectBuffer, IndirectDrawBadVertexIndex8) { + TEST_DESCRIPTION("Validate illegal index buffer values - uint8_t index"); + AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + AddRequiredExtensions(VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME); + RETURN_IF_SKIP(InitGpuAvFramework()); + + AddRequiredFeature(vkt::Feature::indexTypeUint8); + AddDisabledFeature(vkt::Feature::drawIndirectFirstInstance); + AddDisabledFeature(vkt::Feature::robustBufferAccess); + + RETURN_IF_SKIP(InitState()); + InitRenderTarget(); VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vku::InitStructHelper(); vkt::PipelineLayout pipeline_layout(*m_device, pipelineLayoutCreateInfo); + char const *vsSource = R"glsl( + #version 450 + + layout(location=0) in vec3 pos; + + void main() { + gl_Position = vec4(pos, 1.0); + } + )glsl"; + VkShaderObj vs(this, vsSource, VK_SHADER_STAGE_VERTEX_BIT); + CreatePipelineHelper pipe(*this); + VkVertexInputBindingDescription input_binding = {0, 3 * sizeof(float), VK_VERTEX_INPUT_RATE_VERTEX}; + VkVertexInputAttributeDescription input_attrib = {0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0}; + pipe.vi_ci_.pVertexBindingDescriptions = &input_binding; + pipe.vi_ci_.vertexBindingDescriptionCount = 1; + pipe.vi_ci_.pVertexAttributeDescriptions = &input_attrib; + pipe.vi_ci_.vertexAttributeDescriptionCount = 1; pipe.gp_ci_.layout = pipeline_layout.handle(); + pipe.shader_stages_ = {vs.GetStageCreateInfo(), pipe.fs_->GetStageCreateInfo()}; + pipe.CreateGraphicsPipeline(); - m_errorMonitor->SetDesiredError("VUID-VkDrawIndirectCommand-firstInstance-00501"); + VkDrawIndexedIndirectCommand draw_params{}; + draw_params.indexCount = 3; + draw_params.instanceCount = 1; + draw_params.firstIndex = 0; + draw_params.vertexOffset = 0; + draw_params.firstInstance = 0; + vkt::Buffer draw_params_buffer = vkt::IndirectBuffer(*m_device, {draw_params}); + VkCommandBufferBeginInfo begin_info = vku::InitStructHelper(); m_commandBuffer->begin(&begin_info); m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); + vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); - vk::CmdDrawIndirect(m_commandBuffer->handle(), draw_buffer.handle(), 0, 4, sizeof(VkDrawIndirectCommand)); + + vkt::Buffer index_buffer = vkt::IndexBuffer(*m_device, {0, 128, 42}); + vkt::Buffer vertex_buffer = vkt::VertexBuffer(*m_device, {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}); + VkDeviceSize vertex_buffer_offset = 0; + vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT8_KHR); + vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vertex_buffer.handle(), &vertex_buffer_offset); + + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexedIndirect-None-02721", "Vertex index 128"); + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexedIndirect-None-02721", "Vertex index 42"); + vk::CmdDrawIndexedIndirect(m_commandBuffer->handle(), draw_params_buffer.handle(), 0, 1, sizeof(VkDrawIndexedIndirectCommand)); + m_commandBuffer->EndRenderPass(); m_commandBuffer->end(); + m_default_queue->Submit(*m_commandBuffer); m_default_queue->Wait(); m_errorMonitor->VerifyFound(); +} - // Now with an offset and indexed draw - m_errorMonitor->SetDesiredError("VUID-VkDrawIndexedIndirectCommand-firstInstance-00554"); - vkt::Buffer indexed_draw_buffer(*m_device, 4 * sizeof(VkDrawIndexedIndirectCommand), VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); - VkDrawIndexedIndirectCommand *indexed_draw_ptr = (VkDrawIndexedIndirectCommand *)indexed_draw_buffer.memory().map(); - for (uint32_t i = 0; i < 4; i++) { - indexed_draw_ptr->indexCount = 3; - indexed_draw_ptr->instanceCount = 1; - indexed_draw_ptr->firstIndex = 0; - indexed_draw_ptr->vertexOffset = 0; - indexed_draw_ptr->firstInstance = (i == 3) ? 1 : 0; - indexed_draw_ptr++; +TEST_F(NegativeGpuAVIndirectBuffer, DrawBadVertexIndex32) { + TEST_DESCRIPTION("Validate illegal index buffer values - uint32_t index"); + AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + RETURN_IF_SKIP(InitGpuAvFramework()); + + AddDisabledFeature(vkt::Feature::robustBufferAccess); + RETURN_IF_SKIP(InitState()); + InitRenderTarget(); + + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vku::InitStructHelper(); + vkt::PipelineLayout pipeline_layout(*m_device, pipelineLayoutCreateInfo); + + char const *vsSource = R"glsl( + #version 450 + + layout(location=0) in vec3 pos; + + void main() { + gl_Position = vec4(pos, 1.0); + } + )glsl"; + VkShaderObj vs(this, vsSource, VK_SHADER_STAGE_VERTEX_BIT); + + CreatePipelineHelper pipe(*this); + VkVertexInputBindingDescription input_binding = {0, 3 * sizeof(float), VK_VERTEX_INPUT_RATE_VERTEX}; + VkVertexInputAttributeDescription input_attrib = {0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0}; + pipe.vi_ci_.pVertexBindingDescriptions = &input_binding; + pipe.vi_ci_.vertexBindingDescriptionCount = 1; + pipe.vi_ci_.pVertexAttributeDescriptions = &input_attrib; + pipe.vi_ci_.vertexAttributeDescriptionCount = 1; + pipe.gp_ci_.layout = pipeline_layout.handle(); + pipe.shader_stages_ = {vs.GetStageCreateInfo(), pipe.fs_->GetStageCreateInfo()}; + + pipe.CreateGraphicsPipeline(); + + VkCommandBufferBeginInfo begin_info = vku::InitStructHelper(); + m_commandBuffer->begin(&begin_info); + m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); + + vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); + + vkt::Buffer index_buffer = vkt::IndexBuffer(*m_device, {0, 666, 42}); + vkt::Buffer vertex_buffer = vkt::VertexBuffer(*m_device, {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}); + VkDeviceSize vertex_buffer_offset = 0; + vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32); + vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vertex_buffer.handle(), &vertex_buffer_offset); + + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", + "index_buffer\\[1\\] \\(666\\) \\+ vertexOffset \\(0\\) = Vertex index 666"); + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", + "index_buffer\\[2\\] \\(42\\) \\+ vertexOffset \\(0\\) = Vertex index 42"); + vk::CmdDrawIndexed(m_commandBuffer->handle(), 3, 1, 0, 0, 0); + + // vertexOffset = 3 + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", + "index_buffer\\[0\\] \\(0\\) \\+ vertexOffset \\(3\\) = Vertex index 3"); + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", + "index_buffer\\[1\\] \\(666\\) \\+ vertexOffset \\(3\\) = Vertex index 669"); + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", + "index_buffer\\[2\\] \\(42\\) \\+ vertexOffset \\(3\\) = Vertex index 45"); + vk::CmdDrawIndexed(m_commandBuffer->handle(), 3, 1, 0, 3, 0); + + m_commandBuffer->EndRenderPass(); + m_commandBuffer->end(); + + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); + m_errorMonitor->VerifyFound(); +} + +TEST_F(NegativeGpuAVIndirectBuffer, DrawInSecondaryCmdBufferBadVertexIndex32) { + TEST_DESCRIPTION("Validate illegal index buffer values - uint32_t index. Draw recorded in secondary command buffer."); + AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + RETURN_IF_SKIP(InitGpuAvFramework()); + + AddDisabledFeature(vkt::Feature::robustBufferAccess); + RETURN_IF_SKIP(InitState()); + InitRenderTarget(); + + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vku::InitStructHelper(); + vkt::PipelineLayout pipeline_layout(*m_device, pipelineLayoutCreateInfo); + + char const *vsSource = R"glsl( + #version 450 + + layout(location=0) in vec3 pos; + + void main() { + gl_Position = vec4(pos, 1.0); + } + )glsl"; + VkShaderObj vs(this, vsSource, VK_SHADER_STAGE_VERTEX_BIT); + + CreatePipelineHelper pipe(*this); + VkVertexInputBindingDescription input_binding = {0, 3 * sizeof(float), VK_VERTEX_INPUT_RATE_VERTEX}; + VkVertexInputAttributeDescription input_attrib = {0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0}; + pipe.vi_ci_.pVertexBindingDescriptions = &input_binding; + pipe.vi_ci_.vertexBindingDescriptionCount = 1; + pipe.vi_ci_.pVertexAttributeDescriptions = &input_attrib; + pipe.vi_ci_.vertexAttributeDescriptionCount = 1; + pipe.gp_ci_.layout = pipeline_layout.handle(); + pipe.shader_stages_ = {vs.GetStageCreateInfo(), pipe.fs_->GetStageCreateInfo()}; + + pipe.CreateGraphicsPipeline(); + + vkt::Buffer index_buffer = vkt::IndexBuffer(*m_device, {0, 666, 42}); + vkt::Buffer vertex_buffer = vkt::VertexBuffer(*m_device, {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}); + + std::vector secondary_cmd_buffers; + std::vector secondary_cmd_buffers_handles; + + VkCommandBufferInheritanceInfo inheritance_info = vku::InitStructHelper(); + inheritance_info.renderPass = m_renderPass; + inheritance_info.subpass = 0; + inheritance_info.framebuffer = framebuffer(); + + VkCommandBufferBeginInfo secondary_begin_info = vku::InitStructHelper(); + secondary_begin_info.flags = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT; + secondary_begin_info.pInheritanceInfo = &inheritance_info; + + constexpr uint32_t secondary_cmd_buffer_executes_count = 3; + for (uint32_t i = 0; i < secondary_cmd_buffer_executes_count; ++i) { + vkt::CommandBuffer &secondary_cmd_buffer = + secondary_cmd_buffers.emplace_back(*m_device, m_command_pool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); + secondary_cmd_buffers_handles.push_back(secondary_cmd_buffer.handle()); + + secondary_cmd_buffer.begin(&secondary_begin_info); + vk::CmdBindPipeline(secondary_cmd_buffer.handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); + + VkDeviceSize vertex_buffer_offset = 0; + vk::CmdBindIndexBuffer(secondary_cmd_buffer.handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32); + vk::CmdBindVertexBuffers(secondary_cmd_buffer.handle(), 0, 1, &vertex_buffer.handle(), &vertex_buffer_offset); + + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", + "index_buffer\\[1\\] \\(666\\) \\+ vertexOffset \\(0\\) = Vertex index 666"); + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", + "index_buffer\\[2\\] \\(42\\) \\+ vertexOffset \\(0\\) = Vertex index 42"); + vk::CmdDrawIndexed(secondary_cmd_buffer.handle(), 3, 1, 0, 0, 0); + + // vertexOffset = 3 + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", + "index_buffer\\[0\\] \\(0\\) \\+ vertexOffset \\(3\\) = Vertex index 3"); + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", + "index_buffer\\[1\\] \\(666\\) \\+ vertexOffset \\(3\\) = Vertex index 669"); + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", + "index_buffer\\[2\\] \\(42\\) \\+ vertexOffset \\(3\\) = Vertex index 45"); + vk::CmdDrawIndexed(secondary_cmd_buffer.handle(), 3, 1, 0, 3, 0); + + secondary_cmd_buffer.end(); } - indexed_draw_buffer.memory().unmap(); + VkCommandBufferBeginInfo begin_info = vku::InitStructHelper(); + m_commandBuffer->begin(&begin_info); + m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS); + + vk::CmdExecuteCommands(m_commandBuffer->handle(), size32(secondary_cmd_buffers_handles), secondary_cmd_buffers_handles.data()); + + m_commandBuffer->EndRenderPass(); + m_commandBuffer->end(); + + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); + m_errorMonitor->VerifyFound(); +} + +TEST_F(NegativeGpuAVIndirectBuffer, DrawBadVertexIndex16) { + TEST_DESCRIPTION("Validate illegal index buffer values - uint16_t index"); + AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + RETURN_IF_SKIP(InitGpuAvFramework()); + + AddDisabledFeature(vkt::Feature::robustBufferAccess); + RETURN_IF_SKIP(InitState()); + InitRenderTarget(); + + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vku::InitStructHelper(); + vkt::PipelineLayout pipeline_layout(*m_device, pipelineLayoutCreateInfo); + + char const *vsSource = R"glsl( + #version 450 + + layout(location=0) in vec3 pos; + + void main() { + gl_Position = vec4(pos, 1.0); + } + )glsl"; + VkShaderObj vs(this, vsSource, VK_SHADER_STAGE_VERTEX_BIT); + + CreatePipelineHelper pipe(*this); + VkVertexInputBindingDescription input_binding = {0, 3 * sizeof(float), VK_VERTEX_INPUT_RATE_VERTEX}; + VkVertexInputAttributeDescription input_attrib = {0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0}; + pipe.vi_ci_.pVertexBindingDescriptions = &input_binding; + pipe.vi_ci_.vertexBindingDescriptionCount = 1; + pipe.vi_ci_.pVertexAttributeDescriptions = &input_attrib; + pipe.vi_ci_.vertexAttributeDescriptionCount = 1; + pipe.gp_ci_.layout = pipeline_layout.handle(); + pipe.shader_stages_ = {vs.GetStageCreateInfo(), pipe.fs_->GetStageCreateInfo()}; + + pipe.CreateGraphicsPipeline(); + + VkCommandBufferBeginInfo begin_info = vku::InitStructHelper(); m_commandBuffer->begin(&begin_info); m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); + vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); - vkt::Buffer index_buffer(*m_device, 3 * sizeof(uint32_t), VK_BUFFER_USAGE_INDEX_BUFFER_BIT); + + vkt::Buffer index_buffer = vkt::IndexBuffer(*m_device, {0, 666, 3}); + vkt::Buffer vertex_buffer = vkt::VertexBuffer(*m_device, {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}); + VkDeviceSize vertex_buffer_offset = 0; + vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT16); + vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vertex_buffer.handle(), &vertex_buffer_offset); + + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", + "index_buffer\\[1\\] \\(666\\) \\+ vertexOffset \\(0\\) = Vertex index 666"); + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", + "index_buffer\\[2\\] \\(3\\) \\+ vertexOffset \\(0\\) = Vertex index 3"); + vk::CmdDrawIndexed(m_commandBuffer->handle(), 3, 1, 0, 0, 0); + + m_commandBuffer->EndRenderPass(); + m_commandBuffer->end(); + + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); + m_errorMonitor->VerifyFound(); +} + +TEST_F(NegativeGpuAVIndirectBuffer, DrawBadVertexIndex8) { + TEST_DESCRIPTION("Validate illegal index buffer values - uint8_t index"); + AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + AddRequiredExtensions(VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME); + RETURN_IF_SKIP(InitGpuAvFramework()); + + AddRequiredFeature(vkt::Feature::indexTypeUint8); + AddDisabledFeature(vkt::Feature::robustBufferAccess); + RETURN_IF_SKIP(InitState()); + InitRenderTarget(); + + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vku::InitStructHelper(); + vkt::PipelineLayout pipeline_layout(*m_device, pipelineLayoutCreateInfo); + + char const *vsSource = R"glsl( + #version 450 + + layout(location=0) in vec3 pos; + + void main() { + gl_Position = vec4(pos, 1.0); + } + )glsl"; + VkShaderObj vs(this, vsSource, VK_SHADER_STAGE_VERTEX_BIT); + + CreatePipelineHelper pipe(*this); + VkVertexInputBindingDescription input_binding = {0, 3 * sizeof(float), VK_VERTEX_INPUT_RATE_VERTEX}; + VkVertexInputAttributeDescription input_attrib = {0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0}; + pipe.vi_ci_.pVertexBindingDescriptions = &input_binding; + pipe.vi_ci_.vertexBindingDescriptionCount = 1; + pipe.vi_ci_.pVertexAttributeDescriptions = &input_attrib; + pipe.vi_ci_.vertexAttributeDescriptionCount = 1; + pipe.gp_ci_.layout = pipeline_layout.handle(); + pipe.shader_stages_ = {vs.GetStageCreateInfo(), pipe.fs_->GetStageCreateInfo()}; + + pipe.CreateGraphicsPipeline(); + + VkCommandBufferBeginInfo begin_info = vku::InitStructHelper(); + m_commandBuffer->begin(&begin_info); + m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); + + vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); + + vkt::Buffer index_buffer = vkt::IndexBuffer(*m_device, {12, 66, 42}); + vkt::Buffer vertex_buffer = vkt::VertexBuffer(*m_device, {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}); + VkDeviceSize vertex_buffer_offset = 0; + vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT8_KHR); + vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vertex_buffer.handle(), &vertex_buffer_offset); + + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", + "index_buffer\\[0\\] \\(12\\) \\+ vertexOffset \\(0\\) = Vertex index 12"); + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", + "index_buffer\\[1\\] \\(66\\) \\+ vertexOffset \\(0\\) = Vertex index 66"); + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", + "index_buffer\\[2\\] \\(42\\) \\+ vertexOffset \\(0\\) = Vertex index 42"); + vk::CmdDrawIndexed(m_commandBuffer->handle(), 3, 1, 0, 0, 0); + + m_commandBuffer->EndRenderPass(); + m_commandBuffer->end(); + + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); + m_errorMonitor->VerifyFound(); +} + +// #ARNO_TODO: Re-enable those when after adding index buffer validation for vkCmdDrawIndexed +#if 0 +TEST_F(NegativeGpuAVIndirectBuffer, BadVertexIndexDirect) { + TEST_DESCRIPTION("Validate illegal index buffer values for vkCmdDrawIndexed"); + AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + RETURN_IF_SKIP(InitGpuAvFramework()); + + AddDisabledFeature(vkt::Feature::drawIndirectFirstInstance); + AddDisabledFeature(vkt::Feature::robustBufferAccess); + RETURN_IF_SKIP(InitState()); + InitRenderTarget(); + + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vku::InitStructHelper(); + vkt::PipelineLayout pipeline_layout(*m_device, pipelineLayoutCreateInfo); + + CreatePipelineHelper pipe(*this); + pipe.gp_ci_.layout = pipeline_layout.handle(); + pipe.CreateGraphicsPipeline(); + + VkCommandBufferBeginInfo begin_info = vku::InitStructHelper(); + m_commandBuffer->begin(&begin_info); + m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); + vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); + vkt::Buffer index_buffer(*m_device, 4 * sizeof(uint32_t), VK_BUFFER_USAGE_INDEX_BUFFER_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT); + auto *indicies = static_cast(index_buffer.memory().map()); + indicies[0] = 0u; + indicies[1] = 1u; + indicies[2] = 512u; + indicies[3] = 2u; + index_buffer.memory().unmap(); + + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", "index buffer at index 2 is 512"); + vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32); - vk::CmdDrawIndexedIndirect(m_commandBuffer->handle(), indexed_draw_buffer.handle(), sizeof(VkDrawIndexedIndirectCommand), 3, - sizeof(VkDrawIndexedIndirectCommand)); + + vk::CmdDrawIndexed(m_commandBuffer->handle(), 3, 1, 1, 0, 0); + + m_commandBuffer->EndRenderPass(); + m_commandBuffer->end(); + m_default_queue->Submit(*m_commandBuffer); + m_default_queue->Wait(); + m_errorMonitor->VerifyFound(); +} + +TEST_F(NegativeGpuAVIndirectBuffer, BadVertexIndexDirect16) { + TEST_DESCRIPTION("Validate illegal 16 bit index buffer values for vkCmdDrawIndexed"); + AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + RETURN_IF_SKIP(InitGpuAvFramework()); + + AddDisabledFeature(vkt::Feature::drawIndirectFirstInstance); + AddDisabledFeature(vkt::Feature::robustBufferAccess); + RETURN_IF_SKIP(InitState()); + InitRenderTarget(); + + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vku::InitStructHelper(); + vkt::PipelineLayout pipeline_layout(*m_device, pipelineLayoutCreateInfo); + + CreatePipelineHelper pipe(*this); + pipe.gp_ci_.layout = pipeline_layout.handle(); + pipe.CreateGraphicsPipeline(); + + VkCommandBufferBeginInfo begin_info = vku::InitStructHelper(); + m_commandBuffer->begin(&begin_info); + m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); + vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.Handle()); + vkt::Buffer index_buffer(*m_device, 4 * sizeof(uint16_t), VK_BUFFER_USAGE_INDEX_BUFFER_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT); + auto *indicies = static_cast(index_buffer.memory().map()); + indicies[0] = 0u; + indicies[1] = 1u; + indicies[2] = 65535u; + indicies[3] = 2u; + index_buffer.memory().unmap(); + + m_errorMonitor->SetDesiredErrorRegex("VUID-vkCmdDrawIndexed-None-02721", "index buffer at index 2 is 65535"); + + vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT16); + + vk::CmdDrawIndexed(m_commandBuffer->handle(), 3, 1, 1, 0, 0); + m_commandBuffer->EndRenderPass(); m_commandBuffer->end(); m_default_queue->Submit(*m_commandBuffer); m_default_queue->Wait(); m_errorMonitor->VerifyFound(); } +#endif TEST_F(NegativeGpuAVIndirectBuffer, DispatchWorkgroupSize) { TEST_DESCRIPTION("GPU validation: Validate VkDispatchIndirectCommand");