/* Copyright (c) 2019-2024, Sascha Willems
 *
 * 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.
 */

 /*
  * Texture loading (and display) example (including mip maps)
  */

#pragma once

#include <ktx.h>

#include "api_vulkan_sample.h"
#include <thread>
#include <mutex>

  // Vertex layout for this example
struct TextureLoadingVertexStructure
{
	float pos[3];
	float uv[2];
	float normal[3];
};

class TextureLoading : public ApiVulkanSample
{
public:
	// --- 新增：用于点云渲染的结构 ---
	struct PointVertex {
		float x, y, z; // 位置
		float r, g, b; // 颜色 (可以根据需要修改)
	};

	std::unique_ptr<vkb::core::BufferC> point_vertex_buffer;
	uint32_t                            point_count = 0;
	VkPipeline                          point_pipeline;
	VkPipelineLayout                    point_pipeline_layout;
	VkDescriptorSetLayout               point_descriptor_set_layout;
	VkDescriptorSet                     point_descriptor_set;

	void setup_point_descriptor_set_layout();
	void setup_point_descriptor_set();
	void prepare_point_pipeline();
	void update_point_vertex_buffer(float* pos, int pointCount);
	void draw_point_cloud(VkCommandBuffer command_buffer);
	void ReceiveFacePoint(float* pos, int pointCount, int width, int height);
	void update_point_descriptor_set();



	struct Texture
	{
		VkSampler      sampler;
		VkImage        image;
		VkImageLayout  image_layout;
		VkDeviceMemory device_memory;
		VkImageView    view;
		uint32_t       width, height;
		uint32_t       mip_levels;
	};

	Texture texture = { 0 };
	Texture cam_text = { 0 };

	std::unique_ptr<vkb::core::BufferC> vertex_buffer;
	std::unique_ptr<vkb::core::BufferC> index_buffer;
	uint32_t                            index_count;

	std::unique_ptr<vkb::core::BufferC> uniform_buffer_vs;

	struct
	{
		glm::mat4 projection;
		glm::mat4 model;
		glm::vec4 view_pos;
		float     lod_bias = 0.0f;
	} ubo_vs;

	struct
	{
		VkPipeline solid;
		VkPipeline background;
	} pipelines;

	VkPipelineLayout      pipeline_layout;
	VkPipelineLayout      pipeline_layout_bg;
	VkDescriptorSet       descriptor_set;
	VkDescriptorSet       descriptor_set_bg;

	VkDescriptorSetLayout descriptor_set_layout;
	VkDescriptorSetLayout descriptor_set_layout_bg;

	static TextureLoading* Get() {
		return this_instance;
	}

	static TextureLoading* this_instance;

	TextureLoading();
	~TextureLoading();
	virtual void request_gpu_features(vkb::PhysicalDevice& gpu) override;
	void         load_texture();
	void         destroy_texture(Texture texture);
	void         build_command_buffers() override;
	void         draw();
	void         generate_quad();
	void         setup_descriptor_pool();
	void         setup_descriptor_set_layout();
	void         setup_descriptor_set_layout_bg();
	void         setup_descriptor_set();
	void         setup_descriptor_set_bg();
	void         prepare_pipelines();
	void         prepare_uniform_buffers();
	void         update_uniform_buffers();
	bool         prepare(const vkb::ApplicationOptions& options) override;
	virtual void render(float delta_time) override;
	virtual void view_changed() override;
	virtual void on_update_ui_overlay(vkb::Drawer& drawer) override;

	void            processWithVulkan(uint8_t* data, int width, int height, int rowStride, size_t dataSize, Texture& out_texture);
	void            createTexture(VkDevice device, VkPhysicalDevice physicalDevice, int width, int height, Texture& texture);
	void            updateTexture(VkDevice device, VkPhysicalDevice physicalDevice, VkCommandPool commandPool, VkQueue queue, uint8_t* data, int width, int height, int rowStride, size_t dataSize, Texture& texture);
	uint32_t        findMemoryType(VkPhysicalDevice physicalDevice, uint32_t typeFilter, VkMemoryPropertyFlags properties);
	VkCommandBuffer beginSingleTimeCommands(VkDevice device, VkCommandPool commandPool);
	void            endSingleTimeCommands(VkDevice device, VkCommandPool commandPool, VkQueue queue, VkCommandBuffer commandBuffer);
	void            transitionImageLayout(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout oldLayout, VkImageLayout newLayout);

public:
	void prepare_pipeline_bg();
private:
	std::thread workerThread;
	bool running = false;

public:
	//void run();
	//void start();
	std::mutex mtx;
	std::mutex mtx_point;
	//void stop();
	//void updateTexture();
};

std::unique_ptr<vkb::Application> create_texture_loading();