/* Copyright (c) 2023-2025, Mobica
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * 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 "dynamic_blending.h"

#include "common/vk_common.h"
#include "gui.h"

DynamicBlending::DynamicBlending()
{
	add_instance_extension(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
	add_device_extension(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
	add_device_extension(VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME);

	title = "Dynamic blending";
}

DynamicBlending::~DynamicBlending()
{
	if (has_device())
	{
		vkDestroyPipeline(get_device().get_handle(), pipeline, nullptr);
		vkDestroyPipelineLayout(get_device().get_handle(), pipeline_layout, nullptr);
		vkDestroyDescriptorSetLayout(get_device().get_handle(), descriptor_set_layout, nullptr);
		vkDestroyDescriptorPool(get_device().get_handle(), descriptor_pool, nullptr);
	}
}

bool DynamicBlending::prepare(const vkb::ApplicationOptions &options)
{
	if (!ApiVulkanSample::prepare(options))
	{
		return false;
	}

	camera.type = vkb::CameraType::LookAt;
	camera.set_position({0.0f, 0.0f, -5.0f});
	camera.set_rotation({-15.0f, 15.0f, 0.0f});
	camera.set_perspective(45.0f, static_cast<float>(width) / static_cast<float>(height), 256.0f, 0.1f);

	initialize_operator_names();
	prepare_uniform_buffers();
	prepare_scene();
	setup_descriptor_pool();
	create_descriptor_set_layout();
	create_descriptor_set();
	create_pipelines();
	build_command_buffers();

	rnd_engine = std::default_random_engine(time(nullptr));
	rnd_dist   = std::uniform_real_distribution<float>(0.0f, 1.0f);

	prepared = true;

	return true;
}

void DynamicBlending::initialize_operator_names()
{
	for (uint32_t i = VK_BLEND_OP_ADD; i <= VK_BLEND_OP_MAX; ++i)
	{
		VkBlendOp op = static_cast<VkBlendOp>(i);
		blend_operator.values.push_back(op);
		blend_operator.names.push_back(vkb::to_string(op));
	}
	current_blend_color_operator_index = VK_BLEND_OP_ADD;
	current_blend_alpha_operator_index = VK_BLEND_OP_ADD;

	for (uint32_t i = VK_BLEND_OP_ZERO_EXT; i <= VK_BLEND_OP_BLUE_EXT; ++i)
	{
		VkBlendOp op = static_cast<VkBlendOp>(i);
		advanced_blend_operator.values.push_back(op);
		advanced_blend_operator.names.push_back(vkb::to_string(op));
	}
	current_advanced_blend_operator_index = VK_BLEND_OP_SRC_OVER_EXT - VK_BLEND_OP_ZERO_EXT;

	for (uint32_t i = VK_BLEND_FACTOR_ZERO; i <= VK_BLEND_FACTOR_SRC_ALPHA_SATURATE; ++i)
	{
		// The substr(16) call is used to drop the "VK_BLEND_FACTOR_" prefix
		blend_factor_names.push_back(vkb::to_string(static_cast<VkBlendFactor>(i)).substr(16));
	}
}

void DynamicBlending::prepare_scene()
{
	vertices = {
	    {{-1.0f, -1.0f, 1.0f}, {0.0f, 0.0f}},
	    {{1.0f, -1.0f, 1.0f}, {1.0f, 0.0f}},
	    {{1.0f, 1.0f, 1.0f}, {1.0f, 1.0f}},
	    {{-1.0f, 1.0f, 1.0f}, {0.0f, 1.0f}},

	    {{-1.0f, -1.0f, -1.0f}, {0.0f, 0.0f}},
	    {{1.0f, -1.0f, -1.0f}, {1.0f, 0.0f}},
	    {{1.0f, 1.0f, -1.0f}, {1.0f, 1.0f}},
	    {{-1.0f, 1.0f, -1.0f}, {0.0f, 1.0f}},
	};

	std::vector<uint32_t> indices = {
	    6, 5, 4, 4, 7, 6,
	    0, 1, 2, 2, 3, 0};

	index_count = static_cast<uint32_t>(indices.size());

	vertex_buffer_size     = static_cast<uint32_t>(vertices.size() * sizeof(Vertex));
	auto index_buffer_size = indices.size() * sizeof(uint32_t);

	vertex_buffer = std::make_unique<vkb::core::BufferC>(get_device(),
	                                                     vertex_buffer_size,
	                                                     VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
	                                                     VMA_MEMORY_USAGE_GPU_TO_CPU);
	vertex_buffer->update(vertices.data(), vertex_buffer_size);

	index_buffer = std::make_unique<vkb::core::BufferC>(get_device(),
	                                                    index_buffer_size,
	                                                    VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
	                                                    VMA_MEMORY_USAGE_GPU_TO_CPU);
	index_buffer->update(indices.data(), index_buffer_size);

	face_preferences[0].index_offset      = 0;
	face_preferences[0].index_count       = index_count / 2;
	face_preferences[0].color_bit_enabled = {true, true, true, true};
	face_preferences[0].color             = {{{1.0f, 0.0f, 0.0f, 1.0f},
	                                          {0.0f, 1.0f, 0.0f, 1.0f},
	                                          {0.0f, 0.0f, 1.0f, 1.0f},
	                                          {0.0f, 0.0f, 0.0f, 1.0f}}};

	face_preferences[1].index_offset      = index_count / 2;
	face_preferences[1].index_count       = index_count / 2;
	face_preferences[1].color_bit_enabled = {true, true, true, true};
	face_preferences[1].color             = {{{0.0f, 1.0f, 1.0f, 0.5f},
	                                          {1.0f, 0.0f, 1.0f, 0.5f},
	                                          {1.0f, 1.0f, 0.0f, 0.5f},
	                                          {1.0f, 1.0f, 1.0f, 0.5f}}};
}

void DynamicBlending::request_gpu_features(vkb::PhysicalDevice &gpu)
{
	// We must have this or the sample isn't useful
	REQUEST_REQUIRED_FEATURE(gpu,
	                         VkPhysicalDeviceExtendedDynamicState3FeaturesEXT,
	                         VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT,
	                         extendedDynamicState3ColorBlendEnable);

	// Only request the features that we support
	REQUEST_OPTIONAL_FEATURE(gpu,
	                         VkPhysicalDeviceExtendedDynamicState3FeaturesEXT,
	                         VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT,
	                         extendedDynamicState3ColorWriteMask);
	REQUEST_OPTIONAL_FEATURE(gpu,
	                         VkPhysicalDeviceExtendedDynamicState3FeaturesEXT,
	                         VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT,
	                         extendedDynamicState3ColorBlendEnable);
	REQUEST_OPTIONAL_FEATURE(gpu,
	                         VkPhysicalDeviceExtendedDynamicState3FeaturesEXT,
	                         VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT,
	                         extendedDynamicState3ColorBlendAdvanced);
	REQUEST_OPTIONAL_FEATURE(gpu,
	                         VkPhysicalDeviceExtendedDynamicState3FeaturesEXT,
	                         VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT,
	                         extendedDynamicState3ColorBlendEquation);

	REQUEST_REQUIRED_FEATURE(gpu,
	                         VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT,
	                         VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT,
	                         advancedBlendCoherentOperations);
}

void DynamicBlending::prepare_uniform_buffers()
{
	camera_ubo = std::make_unique<vkb::core::BufferC>(get_device(), sizeof(CameraUbo), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);
	color_ubo  = std::make_unique<vkb::core::BufferC>(get_device(), sizeof(ColorUbo), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);
}

void DynamicBlending::update_uniform_buffers()
{
	CameraUbo cam;
	cam.model      = glm::mat4(1.0f);
	cam.model      = glm::translate(cam.model, glm::vec3(0.0f));
	cam.view       = camera.matrices.view;
	cam.projection = camera.matrices.perspective;

	camera_ubo->convert_and_update(cam);

	update_color();

	glm::mat4 invView = glm::inverse(camera.matrices.view);
	glm::vec4 plane0(vertices[0].pos[0], vertices[0].pos[1], vertices[0].pos[2], 1.0f);
	glm::vec4 plane1(vertices[4].pos[0], vertices[4].pos[1], vertices[4].pos[2], 1.0f);

	plane0 = invView * plane0;
	plane1 = invView * plane1;

	reverse = plane0.z < plane1.z;

	rebuild_command_buffers();
}

void DynamicBlending::setup_descriptor_pool()
{
	std::vector<VkDescriptorPoolSize> pool_sizes = {
	    vkb::initializers::descriptor_pool_size(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 2u),
	};

	VkDescriptorPoolCreateInfo descriptor_pool_create_info =
	    vkb::initializers::descriptor_pool_create_info(
	        static_cast<uint32_t>(pool_sizes.size()),
	        pool_sizes.data(),
	        static_cast<uint32_t>(pool_sizes.size()));
	VK_CHECK(vkCreateDescriptorPool(get_device().get_handle(), &descriptor_pool_create_info, nullptr, &descriptor_pool));
}

void DynamicBlending::create_descriptor_set_layout()
{
	std::vector<VkDescriptorSetLayoutBinding> set_layout_bindings = {
	    vkb::initializers::descriptor_set_layout_binding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT, 0u),
	    vkb::initializers::descriptor_set_layout_binding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_FRAGMENT_BIT, 1u)};

	VkDescriptorSetLayoutCreateInfo descriptor_set_layout_create_info = vkb::initializers::descriptor_set_layout_create_info(set_layout_bindings);
	VK_CHECK(vkCreateDescriptorSetLayout(get_device().get_handle(), &descriptor_set_layout_create_info, nullptr, &descriptor_set_layout));

	VkPipelineLayoutCreateInfo pipeline_layout_create_info = vkb::initializers::pipeline_layout_create_info(&descriptor_set_layout);
	VK_CHECK(vkCreatePipelineLayout(get_device().get_handle(), &pipeline_layout_create_info, nullptr, &pipeline_layout));
}

void DynamicBlending::create_descriptor_set()
{
	VkDescriptorSetAllocateInfo alloc_info = vkb::initializers::descriptor_set_allocate_info(descriptor_pool, &descriptor_set_layout, 1u);
	VK_CHECK(vkAllocateDescriptorSets(get_device().get_handle(), &alloc_info, &descriptor_set));

	VkDescriptorBufferInfo buffer_descriptor = create_descriptor(*camera_ubo);
	VkDescriptorBufferInfo color_descriptor  = create_descriptor(*color_ubo);

	std::vector<VkWriteDescriptorSet> write_descriptor_sets = {
	    vkb::initializers::write_descriptor_set(descriptor_set, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0u, &buffer_descriptor),
	    vkb::initializers::write_descriptor_set(descriptor_set, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1u, &color_descriptor),
	};

	vkUpdateDescriptorSets(get_device().get_handle(), static_cast<uint32_t>(write_descriptor_sets.size()), write_descriptor_sets.data(), 0u, nullptr);
}

void DynamicBlending::create_pipelines()
{
	VkPipelineInputAssemblyStateCreateInfo input_assembly_state =
	    vkb::initializers::pipeline_input_assembly_state_create_info(
	        VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
	        0,
	        VK_FALSE);

	VkPipelineRasterizationStateCreateInfo rasterization_state =
	    vkb::initializers::pipeline_rasterization_state_create_info(
	        VK_POLYGON_MODE_FILL,
	        VK_CULL_MODE_NONE,
	        VK_FRONT_FACE_COUNTER_CLOCKWISE,
	        0);

	VkPipelineColorBlendAttachmentState blend_attachment_state =
	    vkb::initializers::pipeline_color_blend_attachment_state(
	        VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT,
	        VK_TRUE);

	VkPipelineColorBlendAdvancedStateCreateInfoEXT blendAdvancedEXT{};
	blendAdvancedEXT.sType        = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT;
	blendAdvancedEXT.blendOverlap = VK_BLEND_OVERLAP_UNCORRELATED_EXT;

	VkPipelineColorBlendStateCreateInfo color_blend_state =
	    vkb::initializers::pipeline_color_blend_state_create_info(
	        1,
	        &blend_attachment_state);

	VkPipelineDepthStencilStateCreateInfo depth_stencil_state =
	    vkb::initializers::pipeline_depth_stencil_state_create_info(
	        VK_TRUE,
	        VK_TRUE,
	        VK_COMPARE_OP_GREATER);

	VkPipelineViewportStateCreateInfo viewport_state =
	    vkb::initializers::pipeline_viewport_state_create_info(1, 1, 0);

	VkPipelineMultisampleStateCreateInfo multisample_state =
	    vkb::initializers::pipeline_multisample_state_create_info(
	        VK_SAMPLE_COUNT_1_BIT,
	        0);

	std::vector<VkDynamicState> dynamic_state_enables = {
	    VK_DYNAMIC_STATE_VIEWPORT,
	    VK_DYNAMIC_STATE_SCISSOR,
	};

	if (eds_feature_support.extendedDynamicState3ColorWriteMask)
	{
		dynamic_state_enables.push_back(VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT);
	}

	if (eds_feature_support.extendedDynamicState3ColorBlendEnable)
	{
		dynamic_state_enables.push_back(VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT);
	}

	switch (current_blend_option)
	{
		case 0:
			if (eds_feature_support.extendedDynamicState3ColorBlendEquation)
			{
				dynamic_state_enables.push_back(VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT);
			}
			break;
		case 1:
			if (eds_feature_support.extendedDynamicState3ColorBlendAdvanced)
			{
				dynamic_state_enables.push_back(VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT);
			}
			break;
	}

	VkPipelineDynamicStateCreateInfo dynamic_state =
	    vkb::initializers::pipeline_dynamic_state_create_info(
	        dynamic_state_enables.data(),
	        static_cast<uint32_t>(dynamic_state_enables.size()),
	        0);

	const std::vector<VkVertexInputBindingDescription> vertex_input_bindings = {
	    vkb::initializers::vertex_input_binding_description(0, sizeof(Vertex), VK_VERTEX_INPUT_RATE_VERTEX),
	};
	const std::vector<VkVertexInputAttributeDescription> vertex_input_attributes = {
	    vkb::initializers::vertex_input_attribute_description(0, 0, VK_FORMAT_R32G32B32_SFLOAT, offsetof(Vertex, pos)),
	    vkb::initializers::vertex_input_attribute_description(0, 1, VK_FORMAT_R32G32_SFLOAT, offsetof(Vertex, uv)),
	};

	VkPipelineVertexInputStateCreateInfo vertex_input_state = vkb::initializers::pipeline_vertex_input_state_create_info();
	vertex_input_state.vertexBindingDescriptionCount        = static_cast<uint32_t>(vertex_input_bindings.size());
	vertex_input_state.pVertexBindingDescriptions           = vertex_input_bindings.data();
	vertex_input_state.vertexAttributeDescriptionCount      = static_cast<uint32_t>(vertex_input_attributes.size());
	vertex_input_state.pVertexAttributeDescriptions         = vertex_input_attributes.data();

	std::array<VkPipelineShaderStageCreateInfo, 2> shader_stages{};
	shader_stages[0] = load_shader("dynamic_blending", "blending.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
	shader_stages[1] = load_shader("dynamic_blending", "blending.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);

	VkGraphicsPipelineCreateInfo graphics_create{VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO};
	graphics_create.pNext               = VK_NULL_HANDLE;
	graphics_create.renderPass          = render_pass;
	graphics_create.pInputAssemblyState = &input_assembly_state;
	graphics_create.pRasterizationState = &rasterization_state;
	graphics_create.pColorBlendState    = &color_blend_state;
	graphics_create.pMultisampleState   = &multisample_state;
	graphics_create.pViewportState      = &viewport_state;
	graphics_create.pDepthStencilState  = &depth_stencil_state;
	graphics_create.pDynamicState       = &dynamic_state;
	graphics_create.pVertexInputState   = &vertex_input_state;
	graphics_create.pTessellationState  = VK_NULL_HANDLE;
	graphics_create.stageCount          = 2;
	graphics_create.pStages             = shader_stages.data();
	graphics_create.layout              = pipeline_layout;

	VK_CHECK(vkCreateGraphicsPipelines(get_device().get_handle(),
	                                   pipeline_cache,
	                                   1,
	                                   &graphics_create,
	                                   VK_NULL_HANDLE,
	                                   &pipeline));
}

void DynamicBlending::update_pipeline()
{
	vkDestroyPipeline(get_device().get_handle(), pipeline, nullptr);
	create_pipelines();
}

void DynamicBlending::update_color()
{
	for (uint32_t face = 0; face < 2; ++face)
	{
		for (uint32_t vertex = 0; vertex < 4; ++vertex)
		{
			auto &input_color             = face_preferences[face].color[vertex];
			color.data[face * 4 + vertex] = glm::vec4(input_color[0], input_color[1], input_color[2], input_color[3]);
		}
	}
	color_ubo->convert_and_update(color);
}

void DynamicBlending::randomize_color(std::array<float, 4> &color, bool alpha)
{
	for (size_t i = 0; i < 3; ++i)
	{
		color[i] = rnd_dist(rnd_engine);
	}
	if (alpha)
	{
		color[3] = rnd_dist(rnd_engine);
	}
}

void DynamicBlending::update_color_uniform()
{
	update_color();
	rebuild_command_buffers();
}

void DynamicBlending::build_command_buffers()
{
	VkCommandBufferBeginInfo command_buffer_begin_info = vkb::initializers::command_buffer_begin_info();

	std::array<VkClearValue, 2> clear_values;
	clear_values[0].color        = {clear_color[0], clear_color[1], clear_color[2], clear_color[3]};
	clear_values[1].depthStencil = {0.0f, 0u};

	VkRenderPassBeginInfo render_pass_begin_info    = vkb::initializers::render_pass_begin_info();
	render_pass_begin_info.renderPass               = render_pass;
	render_pass_begin_info.renderArea.extent.width  = width;
	render_pass_begin_info.renderArea.extent.height = height;
	render_pass_begin_info.clearValueCount          = static_cast<uint32_t>(clear_values.size());
	render_pass_begin_info.pClearValues             = clear_values.data();

	for (uint32_t i = 0u; i < draw_cmd_buffers.size(); ++i)
	{
		render_pass_begin_info.framebuffer = framebuffers[i];
		auto &cmd_buff                     = draw_cmd_buffers[i];

		VK_CHECK(vkBeginCommandBuffer(cmd_buff, &command_buffer_begin_info));

		vkCmdBeginRenderPass(cmd_buff, &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE);

		VkViewport viewport = vkb::initializers::viewport(static_cast<float>(width), static_cast<float>(height), 0.0f, 1.0f);
		vkCmdSetViewport(cmd_buff, 0u, 1u, &viewport);

		VkRect2D scissor = vkb::initializers::rect2D(width, height, 0, 0);
		vkCmdSetScissor(cmd_buff, 0u, 1u, &scissor);

		{
			vkCmdBindDescriptorSets(cmd_buff, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0u, 1u, &descriptor_set, 0u, nullptr);
			vkCmdBindPipeline(cmd_buff, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);

			VkDeviceSize offsets[1] = {0};
			vkCmdBindVertexBuffers(draw_cmd_buffers[i], 0, 1, vertex_buffer->get(), offsets);
			vkCmdBindIndexBuffer(draw_cmd_buffers[i], index_buffer->get_handle(), 0, VK_INDEX_TYPE_UINT32);

			if (eds_feature_support.extendedDynamicState3ColorBlendEnable)
			{
				const VkBool32 blend_enable = this->blend_enable;
				vkCmdSetColorBlendEnableEXT(cmd_buff, 0, 1, &blend_enable);
			}

			if (current_blend_option == 0)
			{
				if (eds_feature_support.extendedDynamicState3ColorBlendEquation)
				{
					VkColorBlendEquationEXT color_blend_equation;
					color_blend_equation.colorBlendOp        = blend_operator.values[current_blend_color_operator_index];
					color_blend_equation.srcColorBlendFactor = static_cast<VkBlendFactor>(current_src_color_blend_factor);
					color_blend_equation.dstColorBlendFactor = static_cast<VkBlendFactor>(current_dst_color_blend_factor);
					color_blend_equation.alphaBlendOp        = blend_operator.values[current_blend_alpha_operator_index];
					color_blend_equation.srcAlphaBlendFactor = static_cast<VkBlendFactor>(current_src_alpha_blend_factor);
					color_blend_equation.dstAlphaBlendFactor = static_cast<VkBlendFactor>(current_dst_alpha_blend_factor);
					vkCmdSetColorBlendEquationEXT(cmd_buff, 0, 1, &color_blend_equation);
				}
			}
			else
			{
				if (eds_feature_support.extendedDynamicState3ColorBlendAdvanced)
				{
					VkColorBlendAdvancedEXT color_blend_advanced;
					color_blend_advanced.advancedBlendOp  = advanced_blend_operator.values[current_advanced_blend_operator_index];
					color_blend_advanced.srcPremultiplied = src_premultiplied;
					color_blend_advanced.dstPremultiplied = dst_premultiplied;
					color_blend_advanced.blendOverlap     = VK_BLEND_OVERLAP_CONJOINT_EXT;
					color_blend_advanced.clampResults     = VK_TRUE;
					vkCmdSetColorBlendAdvancedEXT(cmd_buff, 0, 1, &color_blend_advanced);
				}
			}

			if (reverse)
			{
				build_command_buffer_for_plane(cmd_buff, face_preferences[1]);
				build_command_buffer_for_plane(cmd_buff, face_preferences[0]);
			}
			else
			{
				build_command_buffer_for_plane(cmd_buff, face_preferences[0]);
				build_command_buffer_for_plane(cmd_buff, face_preferences[1]);
			}
		}

		draw_ui(cmd_buff);

		vkCmdEndRenderPass(cmd_buff);

		VK_CHECK(vkEndCommandBuffer(cmd_buff));
	}
}

void DynamicBlending::build_command_buffer_for_plane(VkCommandBuffer &command_buffer, FacePreferences preferences)
{
	if (eds_feature_support.extendedDynamicState3ColorWriteMask)
	{
		std::array<VkColorComponentFlags, 1> color_bit = {
		    (preferences.color_bit_enabled[0] ? VK_COLOR_COMPONENT_R_BIT : 0u) |
		    (preferences.color_bit_enabled[1] ? VK_COLOR_COMPONENT_G_BIT : 0u) |
		    (preferences.color_bit_enabled[2] ? VK_COLOR_COMPONENT_B_BIT : 0u) |
		    (preferences.color_bit_enabled[3] ? VK_COLOR_COMPONENT_A_BIT : 0u)};
		vkCmdSetColorWriteMaskEXT(command_buffer, 0, 1, color_bit.data());
	}
	vkCmdDrawIndexed(command_buffer, preferences.index_count, 1, preferences.index_offset, 0, 0);
}

void DynamicBlending::on_update_ui_overlay(vkb::Drawer &drawer)
{
	uint32_t item_id = 0;

	auto add_color_edit = [&](const char *caption, std::array<float, 4> &color) {
		ImGuiColorEditFlags flags            = ImGuiColorEditFlags_None | ImGuiColorEditFlags_Float;
		float               color_edit_width = 200;
		ImGui::PushID(++item_id);
		if (drawer.color_op<vkb::Drawer::ColorOp::Edit>(caption, color, color_edit_width, flags))
		// if (drawer.color_edit(caption, color, color_edit_width, flags))
		{
			update_color_uniform();
		}
		ImGui::PopID();
	};

	auto add_color_mask_checkbox = [&](const char *caption, bool &enabled, bool same_line = true) {
		ImGui::PushID(++item_id);
		if (drawer.checkbox(caption, &enabled))
		{
			update_color_uniform();
		}
		ImGui::PopID();
		if (same_line)
		{
			ImGui::SameLine();
		}
	};

	auto add_next_button = [&](int32_t &index, int32_t first, int32_t last) {

	};

	auto add_combo_with_button = [&](const char *caption, int32_t &index, int32_t first, int32_t last, std::vector<std::string> names) {
		ImGui::PushID(++item_id);
		if (drawer.button("Next"))
		{
			index = (index + 1) % (last - first + 1);
			update_uniform_buffers();
		}
		ImGui::PopID();
		ImGui::SameLine();
		if (drawer.combo_box(caption, &index, names))
		{
			update_uniform_buffers();
		}
	};

	add_color_edit("Background", clear_color);

	for (int i = 0; i < 2; ++i)
	{
		FacePreferences &current_face = face_preferences[i];
		if (drawer.header(current_face_index == 0 ? "First face" : "Second face"))
		{
			add_color_edit("Top left", current_face.color[0]);
			add_color_edit("Top right", current_face.color[1]);
			add_color_edit("Bottom left", current_face.color[2]);
			add_color_edit("Bottom right", current_face.color[3]);

			ImGui::PushID(++item_id);
			if (drawer.button("Random"))
			{
				for (int i = 0; i < 4; ++i)
				{
					randomize_color(current_face.color[i]);
				}
				update_color();
			}
			ImGui::PopID();

			if (eds_feature_support.extendedDynamicState3ColorWriteMask)
			{
				drawer.text("Color write mask");
				add_color_mask_checkbox("Red", current_face.color_bit_enabled[0]);
				add_color_mask_checkbox("Green", current_face.color_bit_enabled[1]);
				add_color_mask_checkbox("Blue", current_face.color_bit_enabled[2]);
				add_color_mask_checkbox("Alpha", current_face.color_bit_enabled[3], false);
			}
		}
	}

	if (drawer.header("Blending"))
	{
		if (eds_feature_support.extendedDynamicState3ColorBlendEnable)
		{
			if (drawer.checkbox("Enabled", &blend_enable))
			{
				update_color_uniform();
			}
		}
		if (eds_feature_support.extendedDynamicState3ColorBlendAdvanced)
		{
			if (drawer.radio_button("BlendEquationEXT", &current_blend_option, 0))
			{
				update_pipeline();
				update_color_uniform();
			}
			if (drawer.radio_button("BlendAdvancedEXT", &current_blend_option, 1))
			{
				update_pipeline();
				update_color_uniform();
			}
		}
		switch (current_blend_option)
		{
			case 0:
				if (eds_feature_support.extendedDynamicState3ColorBlendEquation)
				{
					if (drawer.header("BlendEquationEXT"))
					{
						add_combo_with_button("Color operator", current_blend_color_operator_index, VK_BLEND_OP_ADD, VK_BLEND_OP_MAX, blend_operator.names);
						add_combo_with_button("SrcColorBlendFactor", current_src_color_blend_factor, VK_BLEND_FACTOR_ZERO, VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, blend_factor_names);
						add_combo_with_button("DstColorBlendFactor", current_dst_color_blend_factor, VK_BLEND_FACTOR_ZERO, VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, blend_factor_names);

						add_combo_with_button("Alpha operator", current_blend_alpha_operator_index, VK_BLEND_OP_ADD, VK_BLEND_OP_MAX, blend_operator.names);
						add_combo_with_button("SrcAlphaBlendFactor", current_src_alpha_blend_factor, VK_BLEND_FACTOR_ZERO, VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, blend_factor_names);
						add_combo_with_button("DstAlphaBlendFactor", current_dst_alpha_blend_factor, VK_BLEND_FACTOR_ZERO, VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, blend_factor_names);
					}
				}
				break;
			case 1:
				if (eds_feature_support.extendedDynamicState3ColorBlendAdvanced)
				{
					if (drawer.header("BlendAdvancedEXT"))
					{
						add_combo_with_button("Operator", current_advanced_blend_operator_index, VK_BLEND_OP_ZERO_EXT, VK_BLEND_OP_BLUE_EXT, advanced_blend_operator.names);
						if (drawer.checkbox("Src premultiplied", &src_premultiplied))
						{
							update_color_uniform();
						}
						if (drawer.checkbox("Dst premultiplied", &dst_premultiplied))
						{
							update_color_uniform();
						}
					}
				}
				break;
		}
	}
}

void DynamicBlending::render(float delta_time)
{
	if (!prepared)
	{
		return;
	}
	draw();
	if (camera.updated)
	{
		update_uniform_buffers();
	}
}

void DynamicBlending::draw()
{
	ApiVulkanSample::prepare_frame();
	submit_info.commandBufferCount = 1;
	submit_info.pCommandBuffers    = &draw_cmd_buffers[current_buffer];

	VK_CHECK(vkQueueSubmit(queue, 1u, &submit_info, VK_NULL_HANDLE));
	ApiVulkanSample::submit_frame();

	VkPipelineStageFlags wait_stage_mask = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
}

bool DynamicBlending::resize(const uint32_t width, const uint32_t height)
{
	ApiVulkanSample::resize(width, height);
	update_uniform_buffers();
	return true;
}

std::unique_ptr<vkb::VulkanSampleC> create_dynamic_blending()
{
	return std::make_unique<DynamicBlending>();
}