2346 lines
94 KiB
C++
2346 lines
94 KiB
C++
|
|
|
|
#include "texture_loading.h"
|
|
#include "lodepng.cpp"
|
|
//#ifdef _WIN32
|
|
// #include <nlohmann/json.hpp>
|
|
// #include <iostream>
|
|
// #include <fstream>
|
|
// #include <string>
|
|
//#endif
|
|
|
|
using namespace std;
|
|
|
|
TextureLoading::TextureLoading()
|
|
{
|
|
zoom = -1.f;
|
|
//rotation = { 0.0f, 15.0f, 0.0f };
|
|
rotation = { 0.0f, 0.0f, 0.0f };
|
|
title = "Texture loading";
|
|
this_instance = this;
|
|
}
|
|
|
|
TextureLoading::~TextureLoading()
|
|
{
|
|
if (has_device())
|
|
{
|
|
// Clean up used Vulkan resources
|
|
// Note : Inherited destructor cleans up resources stored in base class
|
|
|
|
vkDestroyPipeline(get_device().get_handle(), pipelines.solid, nullptr);
|
|
vkDestroyPipeline(get_device().get_handle(), pipelines.background, nullptr);
|
|
vkDestroyPipeline(get_device().get_handle(), pipelines.point, nullptr);
|
|
vkDestroyPipeline(get_device().get_handle(), pipelines.line, nullptr);
|
|
|
|
vkDestroyPipelineLayout(get_device().get_handle(), pipeline_layout, nullptr);
|
|
vkDestroyPipelineLayout(get_device().get_handle(), pipeline_layout_bg, nullptr);
|
|
vkDestroyPipelineLayout(get_device().get_handle(), pipeline_layout_point, nullptr);
|
|
vkDestroyPipelineLayout(get_device().get_handle(), pipeline_layout_point_line, nullptr);
|
|
|
|
vkDestroyDescriptorSetLayout(get_device().get_handle(), descriptor_set_layout, nullptr);
|
|
vkDestroyDescriptorSetLayout(get_device().get_handle(), descriptor_set_layout_bg, nullptr);
|
|
vkDestroyDescriptorSetLayout(get_device().get_handle(), descriptor_set_layout_point, nullptr);
|
|
vkDestroyDescriptorSetLayout(get_device().get_handle(), descriptor_set_layout_point_line, nullptr);
|
|
|
|
}
|
|
|
|
destroy_texture(texture);
|
|
destroy_texture(tex_demo1);
|
|
destroy_texture(tex_demo2);
|
|
destroy_texture(tex_demo3);
|
|
destroy_texture(tex_demo4);
|
|
destroy_texture(texture_point);
|
|
destroy_texture(texture_point_line);
|
|
destroy_texture(cam_text);
|
|
|
|
vertex_buffer.reset();
|
|
index_buffer.reset();
|
|
uniform_buffer_vs.reset();
|
|
uniform_buffer_vs_point.reset();
|
|
uniform_buffer_DashParameters.reset();
|
|
|
|
|
|
vertex_buffer_point.reset(); // BufferC 会自动清理
|
|
//stop();
|
|
}
|
|
|
|
// Enable physical device features required for this example
|
|
void TextureLoading::request_gpu_features(vkb::PhysicalDevice& gpu)
|
|
{
|
|
// Enable anisotropic filtering if supported
|
|
if (gpu.get_features().samplerAnisotropy)
|
|
{
|
|
gpu.get_mutable_requested_features().samplerAnisotropy = VK_TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void hslToRgb(float h, float s, float l, uint8_t& r, uint8_t& g, uint8_t& b) {
|
|
float c = (1 - std::abs(2 * l - 1)) * s;
|
|
float x = c * (1 - std::abs(std::fmod(h / 60.0f, 2.0f) - 1));
|
|
float m = l - c / 2.0f;
|
|
|
|
float r_, g_, b_;
|
|
|
|
if (h < 60) {
|
|
r_ = c; g_ = x; b_ = 0;
|
|
}
|
|
else if (h < 120) {
|
|
r_ = x; g_ = c; b_ = 0;
|
|
}
|
|
else if (h < 180) {
|
|
r_ = 0; g_ = c; b_ = x;
|
|
}
|
|
else if (h < 240) {
|
|
r_ = 0; g_ = x; b_ = c;
|
|
}
|
|
else if (h < 300) {
|
|
r_ = x; g_ = 0; b_ = c;
|
|
}
|
|
else {
|
|
r_ = c; g_ = 0; b_ = x;
|
|
}
|
|
|
|
r = static_cast<uint8_t>((r_ + m) * 255);
|
|
g = static_cast<uint8_t>((g_ + m) * 255);
|
|
b = static_cast<uint8_t>((b_ + m) * 255);
|
|
}
|
|
|
|
std::vector<uint8_t> generateSimpleTestImage(int width, int height, int cell_width) {
|
|
std::vector<uint8_t> imageData(width * height * 4);
|
|
|
|
int gridCols = (width + cell_width - 1) / cell_width;
|
|
int gridRows = (height + cell_width - 1) / cell_width;
|
|
|
|
// 存储每个单元格的颜色
|
|
std::vector<std::vector<std::vector<uint8_t>>> cellColors(
|
|
gridRows,
|
|
std::vector<std::vector<uint8_t>>(
|
|
gridCols,
|
|
std::vector<uint8_t>(4)
|
|
)
|
|
);
|
|
|
|
// 为每个单元格生成不同的颜色
|
|
for (int gridY = 0; gridY < gridRows; ++gridY) {
|
|
for (int gridX = 0; gridX < gridCols; ++gridX) {
|
|
// 使用网格坐标生成HSL颜色
|
|
float hue = static_cast<float>(gridX + gridY * gridCols) / (gridCols * gridRows) * 360.0f;
|
|
float saturation = 0.7f + 0.3f * static_cast<float>(gridX % 2); // 交替饱和度
|
|
float lightness = 0.5f + 0.2f * static_cast<float>(gridY % 2); // 交替亮度
|
|
|
|
uint8_t r, g, b;
|
|
hslToRgb(hue, saturation, lightness, r, g, b);
|
|
|
|
cellColors[gridY][gridX][0] = r;
|
|
cellColors[gridY][gridX][1] = g;
|
|
cellColors[gridY][gridX][2] = b;
|
|
cellColors[gridY][gridX][3] = 255;
|
|
if (gridY == 0 && gridX == 0)
|
|
{
|
|
cellColors[gridY][gridX][0] = 0;
|
|
cellColors[gridY][gridX][1] = 0;
|
|
cellColors[gridY][gridX][2] = 0;
|
|
cellColors[gridY][gridX][3] = 255;
|
|
}
|
|
|
|
if (gridY == 0 && gridX == gridCols-1)
|
|
{
|
|
cellColors[gridY][gridX][0] = 255;
|
|
cellColors[gridY][gridX][1] = 0;
|
|
cellColors[gridY][gridX][2] = 0;
|
|
cellColors[gridY][gridX][3] = 255;
|
|
}
|
|
|
|
if (gridY == gridRows-1 && gridX == 0)
|
|
{
|
|
cellColors[gridY][gridX][0] = 0;
|
|
cellColors[gridY][gridX][1] = 0;
|
|
cellColors[gridY][gridX][2] = 255;
|
|
cellColors[gridY][gridX][3] = 255;
|
|
}
|
|
|
|
if (gridY == gridRows - 1 && gridX == gridCols - 1)
|
|
{
|
|
cellColors[gridY][gridX][0] = 255;
|
|
cellColors[gridY][gridX][1] = 255;
|
|
cellColors[gridY][gridX][2] = 255;
|
|
cellColors[gridY][gridX][3] = 255;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 填充像素数据
|
|
for (int y = 0; y < height; ++y) {
|
|
int gridY = y / cell_width;
|
|
|
|
for (int x = 0; x < width; ++x) {
|
|
int gridX = x / cell_width;
|
|
|
|
if (gridY < gridRows && gridX < gridCols) {
|
|
const uint8_t* color = cellColors[gridY][gridX].data();
|
|
int index = (y * width + x) * 4;
|
|
|
|
imageData[index] = color[0]/5;
|
|
imageData[index + 1] = color[1]/3;
|
|
imageData[index + 2] = color[2]/3;
|
|
imageData[index + 3] = color[3]/3;
|
|
}
|
|
}
|
|
}
|
|
|
|
return imageData;
|
|
}
|
|
|
|
|
|
|
|
// Free all Vulkan resources used by a texture object
|
|
void TextureLoading::destroy_texture(Texture texture)
|
|
{
|
|
vkDestroyImageView(get_device().get_handle(), texture.view, nullptr);
|
|
vkDestroyImage(get_device().get_handle(), texture.image, nullptr);
|
|
vkDestroySampler(get_device().get_handle(), texture.sampler, nullptr);
|
|
vkFreeMemory(get_device().get_handle(), texture.device_memory, nullptr);
|
|
}
|
|
|
|
|
|
|
|
void TextureLoading::build_command_buffers()
|
|
{
|
|
VkCommandBufferBeginInfo command_buffer_begin_info = vkb::initializers::command_buffer_begin_info();
|
|
|
|
VkClearValue clear_values[2];
|
|
clear_values[0].color = default_clear_color;
|
|
clear_values[1].depthStencil = { 0.0f, 0 };
|
|
|
|
VkRenderPassBeginInfo render_pass_begin_info = vkb::initializers::render_pass_begin_info();
|
|
render_pass_begin_info.renderPass = render_pass;
|
|
render_pass_begin_info.renderArea.offset.x = 0;
|
|
render_pass_begin_info.renderArea.offset.y = 0;
|
|
render_pass_begin_info.renderArea.extent.width = width;
|
|
render_pass_begin_info.renderArea.extent.height = height;
|
|
render_pass_begin_info.clearValueCount = 2;
|
|
render_pass_begin_info.pClearValues = clear_values;
|
|
|
|
for (int32_t i = 0; i < draw_cmd_buffers.size(); ++i)
|
|
{
|
|
// Set target frame buffer
|
|
render_pass_begin_info.framebuffer = framebuffers[i];
|
|
|
|
VK_CHECK(vkBeginCommandBuffer(draw_cmd_buffers[i], &command_buffer_begin_info));
|
|
|
|
vkCmdBeginRenderPass(draw_cmd_buffers[i], &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(draw_cmd_buffers[i], 0, 1, &viewport);
|
|
|
|
VkRect2D scissor = vkb::initializers::rect2D(width, height, 0, 0);
|
|
vkCmdSetScissor(draw_cmd_buffers[i], 0, 1, &scissor);
|
|
|
|
vkCmdBindDescriptorSets(draw_cmd_buffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout_bg, 0, 1, &descriptor_set_bg, 0, NULL);
|
|
vkCmdBindPipeline(draw_cmd_buffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.background);
|
|
|
|
|
|
vkCmdPushConstants(draw_cmd_buffers[i], pipeline_layout_bg, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(float), &myFloatValue);
|
|
|
|
vkCmdDraw(draw_cmd_buffers[i], 6, 1, 0, 0);
|
|
|
|
|
|
|
|
//draw_point_cloud(draw_cmd_buffers[i]);
|
|
//draw_point_cloud_line(draw_cmd_buffers[i]);
|
|
|
|
|
|
vkCmdBindDescriptorSets(draw_cmd_buffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, 1, &descriptor_set, 0, NULL);
|
|
vkCmdBindPipeline(draw_cmd_buffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.solid);
|
|
|
|
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 (getCurrentTimeMillis() - last_update_time < 1000)
|
|
{
|
|
vkCmdDrawIndexed(draw_cmd_buffers[i], index_count, 1, 0, 0, 0);
|
|
}
|
|
|
|
//draw_ui(draw_cmd_buffers[i]);
|
|
|
|
vkCmdEndRenderPass(draw_cmd_buffers[i]);
|
|
|
|
VK_CHECK(vkEndCommandBuffer(draw_cmd_buffers[i]));
|
|
}
|
|
}
|
|
|
|
void TextureLoading::draw()
|
|
{
|
|
std::unique_lock<std::mutex> lock(mtx);
|
|
std::unique_lock<std::mutex> lock_point(mtx_point);
|
|
std::lock_guard<std::mutex> lock_line(mtx_point_line);
|
|
std::unique_lock<std::mutex> lock_mvp(mtx_mvp);
|
|
ApiVulkanSample::prepare_frame();
|
|
|
|
|
|
// --- 新增：在命令缓冲区中绘制点云 ---
|
|
// 在 build_command_buffers 中已经构建了命令缓冲区，但点数据是动态的。
|
|
// 因此，我们在这里重新记录命令缓冲区。
|
|
// 注意：更高效的做法是使用动态顶点缓冲区或间接绘制，但对于 Demo 来说，重新记录是可以接受的。
|
|
build_command_buffers(); // 重新构建所有命令缓冲区以包含最新的点云
|
|
|
|
// Command buffer to be submitted to the queue
|
|
submit_info.commandBufferCount = 1;
|
|
submit_info.pCommandBuffers = &draw_cmd_buffers[current_buffer];
|
|
|
|
// Submit to queue
|
|
VK_CHECK(vkQueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE));
|
|
|
|
ApiVulkanSample::submit_frame();
|
|
}
|
|
|
|
#include <vector>
|
|
#include <string>
|
|
#include <fstream>
|
|
#include <sstream>
|
|
#include <unordered_map>
|
|
|
|
|
|
bool TextureLoading::LoadOBJ_test(const std::string& filename, std::vector<float>& temp_positions)
|
|
{
|
|
std::ifstream file(filename);
|
|
if (!file.is_open()) {
|
|
return false;
|
|
}
|
|
temp_positions.clear();
|
|
std::string line;
|
|
while (std::getline(file, line)) {
|
|
// 跳过空行和注释行
|
|
if (line.empty() || line[0] == '#') {
|
|
continue;
|
|
}
|
|
|
|
std::istringstream iss(line);
|
|
std::string type;
|
|
iss >> type;
|
|
|
|
if (type == "v") { // 顶点位置
|
|
float x, y, z;
|
|
iss >> x >> y >> z;
|
|
temp_positions.push_back(x);
|
|
temp_positions.push_back(y);
|
|
temp_positions.push_back(z);
|
|
}
|
|
}
|
|
file.close();
|
|
return true;
|
|
}
|
|
|
|
bool TextureLoading::LoadOBJ(const std::string& filename,
|
|
std::vector<TextureLoadingVertexStructure>& vertices,
|
|
std::vector<uint32_t>& indices) {
|
|
|
|
// 临时存储从OBJ文件读取的原始数据
|
|
std::vector<float> temp_positions;
|
|
std::vector<float> temp_texcoords;
|
|
std::vector<float> temp_normals;
|
|
|
|
// 用于处理顶点索引
|
|
std::vector<int> vertexIndices, uvIndices, normalIndices;
|
|
|
|
std::ifstream file(filename);
|
|
if (!file.is_open()) {
|
|
return false;
|
|
}
|
|
|
|
std::string line;
|
|
while (std::getline(file, line)) {
|
|
// 跳过空行和注释行
|
|
if (line.empty() || line[0] == '#') {
|
|
continue;
|
|
}
|
|
|
|
std::istringstream iss(line);
|
|
std::string type;
|
|
iss >> type;
|
|
|
|
if (type == "v") { // 顶点位置
|
|
float x, y, z;
|
|
iss >> x >> y >> z;
|
|
temp_positions.push_back(x);
|
|
temp_positions.push_back(y);
|
|
temp_positions.push_back(z);
|
|
}
|
|
else if (type == "vt") { // 纹理坐标
|
|
float u, v;
|
|
iss >> u >> v;
|
|
temp_texcoords.push_back(u);
|
|
temp_texcoords.push_back(1-v);
|
|
}
|
|
else if (type == "vn") { // 法线
|
|
float nx, ny, nz;
|
|
iss >> nx >> ny >> nz;
|
|
temp_normals.push_back(nx);
|
|
temp_normals.push_back(ny);
|
|
temp_normals.push_back(nz);
|
|
}
|
|
else if (type == "f") { // 面（三角形）
|
|
std::string vertex1, vertex2, vertex3;
|
|
iss >> vertex1 >> vertex2 >> vertex3;
|
|
|
|
// 处理每个顶点的索引
|
|
for (const std::string& vertex : { vertex1, vertex2, vertex3 }) {
|
|
std::istringstream viss(vertex);
|
|
std::string v, vt, vn;
|
|
|
|
// 解析顶点索引格式：v/vt/vn 或 v//vn 或 v
|
|
std::getline(viss, v, '/');
|
|
std::getline(viss, vt, '/');
|
|
std::getline(viss, vn, '/');
|
|
|
|
int posIndex = std::stoi(v) - 1; // OBJ索引从1开始
|
|
int texIndex = -1, normIndex = -1;
|
|
|
|
if (!vt.empty()) texIndex = std::stoi(vt) - 1;
|
|
if (!vn.empty()) normIndex = std::stoi(vn) - 1;
|
|
|
|
vertexIndices.push_back(posIndex);
|
|
uvIndices.push_back(texIndex);
|
|
normalIndices.push_back(normIndex);
|
|
}
|
|
}
|
|
}
|
|
file.close();
|
|
|
|
// 创建顶点数据
|
|
vertices.clear();
|
|
indices.clear();
|
|
|
|
// 用于去重的哈希映射
|
|
std::unordered_map<std::string, uint32_t> vertexMap;
|
|
|
|
for (size_t i = 0; i < vertexIndices.size(); i++) {
|
|
int posIndex = vertexIndices[i];
|
|
int texIndex = uvIndices[i];
|
|
int normIndex = normalIndices[i];
|
|
|
|
// 创建唯一标识符
|
|
std::string vertexKey = std::to_string(posIndex) + "/" +
|
|
std::to_string(texIndex) + "/" +
|
|
std::to_string(normIndex);
|
|
|
|
// 检查是否已经存在相同的顶点
|
|
if (vertexMap.find(vertexKey) != vertexMap.end()) {
|
|
// 使用现有顶点的索引
|
|
indices.push_back(vertexMap[vertexKey]);
|
|
}
|
|
else {
|
|
// 创建新顶点
|
|
TextureLoadingVertexStructure vertex;
|
|
|
|
// 设置位置
|
|
if (posIndex >= 0 && posIndex * 3 + 2 < temp_positions.size()) {
|
|
vertex.pos[0] = temp_positions[posIndex * 3];
|
|
vertex.pos[1] = temp_positions[posIndex * 3 + 1];
|
|
vertex.pos[2] = temp_positions[posIndex * 3 + 2];
|
|
}
|
|
else {
|
|
vertex.pos[0] = vertex.pos[1] = vertex.pos[2] = 0.0f;
|
|
}
|
|
|
|
// 设置纹理坐标
|
|
if (texIndex >= 0 && texIndex * 2 + 1 < temp_texcoords.size()) {
|
|
vertex.uv[0] = temp_texcoords[texIndex * 2];
|
|
vertex.uv[1] = temp_texcoords[texIndex * 2 + 1];
|
|
}
|
|
else {
|
|
vertex.uv[0] = vertex.uv[1] = 0.0f;
|
|
}
|
|
|
|
// 设置法线
|
|
if (normIndex >= 0 && normIndex * 3 + 2 < temp_normals.size()) {
|
|
vertex.normal[0] = temp_normals[normIndex * 3];
|
|
vertex.normal[1] = temp_normals[normIndex * 3 + 1];
|
|
vertex.normal[2] = temp_normals[normIndex * 3 + 2];
|
|
}
|
|
else {
|
|
vertex.normal[0] = vertex.normal[1] = 0.0f;
|
|
vertex.normal[2] = 1.0f; // 默认法线
|
|
}
|
|
|
|
// 添加新顶点并记录索引
|
|
uint32_t newIndex = static_cast<uint32_t>(vertices.size());
|
|
vertices.push_back(vertex);
|
|
indices.push_back(newIndex);
|
|
obj_vertices_map[newIndex] = posIndex;
|
|
vertexMap[vertexKey] = newIndex;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void TextureLoading::generate_quad()
|
|
{
|
|
|
|
//std::vector<TextureLoadingVertexStructure> vertices =
|
|
//{
|
|
// {{0.3f, 0.3f, 0.0f}, {1.0f, 1.0f}, {0.0f, 0.0f, 1.0f}},
|
|
// {{-0.3f, 0.3f, 0.0f}, {0.0f, 1.0f}, {0.0f, 0.0f, 1.0f}},
|
|
// {{-0.3f, -0.3f, 0.0f}, {0.0f, 0.0f}, {0.0f, 0.0f, 1.0f}},
|
|
// {{0.3f, -0.3f, 0.0f}, {1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}} };
|
|
|
|
//std::vector<uint32_t> indices = { 0, 1, 2, 2, 3, 0 };
|
|
|
|
std::vector<TextureLoadingVertexStructure>& vertices = obj_vertices;
|
|
std::vector<uint32_t> indices = obj_indices;
|
|
|
|
index_count = static_cast<uint32_t>(indices.size());
|
|
|
|
auto vertex_buffer_size = vkb::to_u32(vertices.size() * sizeof(TextureLoadingVertexStructure));
|
|
auto index_buffer_size = vkb::to_u32(indices.size() * sizeof(uint32_t));
|
|
|
|
// Create buffers
|
|
// For the sake of simplicity we won't stage the vertex data to the gpu memory
|
|
// Vertex buffer
|
|
vertex_buffer = std::make_unique<vkb::core::BufferC>(get_device(),
|
|
vertex_buffer_size,
|
|
VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
|
|
VMA_MEMORY_USAGE_CPU_TO_GPU);
|
|
vertex_buffer->update(vertices.data(), vertex_buffer_size);
|
|
|
|
index_buffer = std::make_unique<vkb::core::BufferC>(get_device(),
|
|
index_buffer_size,
|
|
VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
|
|
VMA_MEMORY_USAGE_CPU_TO_GPU);
|
|
|
|
index_buffer->update(indices.data(), index_buffer_size);
|
|
}
|
|
|
|
void TextureLoading::setup_descriptor_pool()
|
|
{
|
|
// Example uses one ubo and one image sampler
|
|
std::vector<VkDescriptorPoolSize> pool_sizes =
|
|
{
|
|
vkb::initializers::descriptor_pool_size(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 6),
|
|
vkb::initializers::descriptor_pool_size(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 6) };
|
|
|
|
VkDescriptorPoolCreateInfo descriptor_pool_create_info =
|
|
vkb::initializers::descriptor_pool_create_info(
|
|
static_cast<uint32_t>(pool_sizes.size()),
|
|
pool_sizes.data(),
|
|
6);
|
|
|
|
VK_CHECK(vkCreateDescriptorPool(get_device().get_handle(), &descriptor_pool_create_info, nullptr, &descriptor_pool));
|
|
}
|
|
|
|
|
|
|
|
|
|
void TextureLoading::setup_descriptor_set_layout()
|
|
{
|
|
std::vector<VkDescriptorSetLayoutBinding> set_layout_bindings =
|
|
{
|
|
// Binding 0 : Vertex shader uniform buffer
|
|
vkb::initializers::descriptor_set_layout_binding(
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
|
VK_SHADER_STAGE_VERTEX_BIT,
|
|
0),
|
|
// Binding 1 : Fragment shader image sampler
|
|
vkb::initializers::descriptor_set_layout_binding(
|
|
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
|
|
VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
1) };
|
|
|
|
VkDescriptorSetLayoutCreateInfo descriptor_layout =
|
|
vkb::initializers::descriptor_set_layout_create_info(
|
|
set_layout_bindings.data(),
|
|
static_cast<uint32_t>(set_layout_bindings.size()));
|
|
|
|
VK_CHECK(vkCreateDescriptorSetLayout(get_device().get_handle(), &descriptor_layout, nullptr, &descriptor_set_layout));
|
|
|
|
|
|
VkPipelineLayoutCreateInfo pipeline_layout_create_info =
|
|
vkb::initializers::pipeline_layout_create_info(
|
|
&descriptor_set_layout,
|
|
1);
|
|
|
|
VkPushConstantRange pushConstantRange{};
|
|
pushConstantRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; // 只在片段着色器中使用
|
|
pushConstantRange.offset = 0;
|
|
pushConstantRange.size = sizeof(float); // 或者 sizeof(PushConstants)
|
|
|
|
pipeline_layout_create_info.pushConstantRangeCount = 1;
|
|
pipeline_layout_create_info.pPushConstantRanges = &pushConstantRange;
|
|
|
|
VK_CHECK(vkCreatePipelineLayout(get_device().get_handle(), &pipeline_layout_create_info, nullptr, &pipeline_layout));
|
|
}
|
|
|
|
void TextureLoading::setup_descriptor_set()
|
|
{
|
|
VkDescriptorSetAllocateInfo alloc_info =
|
|
vkb::initializers::descriptor_set_allocate_info(
|
|
descriptor_pool,
|
|
&descriptor_set_layout,
|
|
1);
|
|
|
|
VK_CHECK(vkAllocateDescriptorSets(get_device().get_handle(), &alloc_info, &descriptor_set));
|
|
|
|
VkDescriptorBufferInfo buffer_descriptor = create_descriptor(*uniform_buffer_vs);
|
|
|
|
// Setup a descriptor image info for the current texture to be used as a combined image sampler
|
|
VkDescriptorImageInfo image_descriptor;
|
|
image_descriptor.imageView = texture.view; // The image's view (images are never directly accessed by the shader, but rather through views defining subresources)
|
|
image_descriptor.sampler = texture.sampler; // The sampler (Telling the pipeline how to sample the texture, including repeat, border, etc.)
|
|
image_descriptor.imageLayout = texture.image_layout; // The current layout of the image (Note: Should always fit the actual use, e.g. shader read)
|
|
|
|
std::vector<VkWriteDescriptorSet> write_descriptor_sets =
|
|
{
|
|
// Binding 0 : Vertex shader uniform buffer
|
|
vkb::initializers::write_descriptor_set(
|
|
descriptor_set,
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
|
0,
|
|
&buffer_descriptor),
|
|
// Binding 1 : Fragment shader texture sampler
|
|
// Fragment shader: layout (binding = 1) uniform sampler2D samplerColor;
|
|
vkb::initializers::write_descriptor_set(
|
|
descriptor_set,
|
|
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, // The descriptor set will use a combined image sampler (sampler and image could be split)
|
|
1, // Shader binding point 1
|
|
&image_descriptor) // Pointer to the descriptor image for our texture
|
|
};
|
|
|
|
vkUpdateDescriptorSets(get_device().get_handle(), static_cast<uint32_t>(write_descriptor_sets.size()), write_descriptor_sets.data(), 0, NULL);
|
|
}
|
|
|
|
void TextureLoading::update_texture(Texture& new_texture)
|
|
{
|
|
std::unique_lock<std::mutex> lock(mtx);
|
|
auto current_texture = &new_texture;
|
|
|
|
// 更新descriptor set
|
|
VkDescriptorImageInfo image_descriptor{};
|
|
image_descriptor.imageView = current_texture->view;
|
|
image_descriptor.sampler = current_texture->sampler;
|
|
image_descriptor.imageLayout = current_texture->image_layout;
|
|
|
|
VkWriteDescriptorSet write_descriptor_set =
|
|
vkb::initializers::write_descriptor_set(
|
|
descriptor_set,
|
|
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
|
|
1, // 纹理绑定点
|
|
&image_descriptor);
|
|
|
|
vkUpdateDescriptorSets(
|
|
get_device().get_handle(),
|
|
1,
|
|
&write_descriptor_set,
|
|
0,
|
|
nullptr);
|
|
}
|
|
|
|
void TextureLoading::setup_descriptor_set_layout_bg()
|
|
{
|
|
std::vector<VkDescriptorSetLayoutBinding> set_layout_bindings =
|
|
{
|
|
// Binding 1 : Fragment shader image sampler
|
|
vkb::initializers::descriptor_set_layout_binding(
|
|
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
|
|
VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
0) };
|
|
|
|
VkDescriptorSetLayoutCreateInfo descriptor_layout =
|
|
vkb::initializers::descriptor_set_layout_create_info(
|
|
set_layout_bindings.data(),
|
|
static_cast<uint32_t>(set_layout_bindings.size()));
|
|
|
|
VK_CHECK(vkCreateDescriptorSetLayout(get_device().get_handle(), &descriptor_layout, nullptr, &descriptor_set_layout_bg));
|
|
|
|
VkPipelineLayoutCreateInfo pipeline_layout_create_info =
|
|
vkb::initializers::pipeline_layout_create_info(
|
|
&descriptor_set_layout_bg,
|
|
1);
|
|
|
|
VkPushConstantRange pushConstantRange{};
|
|
pushConstantRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; // 只在片段着色器中使用
|
|
pushConstantRange.offset = 0;
|
|
pushConstantRange.size = sizeof(float); // 或者 sizeof(PushConstants)
|
|
|
|
pipeline_layout_create_info.pushConstantRangeCount = 1;
|
|
pipeline_layout_create_info.pPushConstantRanges = &pushConstantRange;
|
|
|
|
VK_CHECK(vkCreatePipelineLayout(get_device().get_handle(), &pipeline_layout_create_info, nullptr, &pipeline_layout_bg));
|
|
}
|
|
|
|
void TextureLoading::setup_descriptor_set_bg()
|
|
{
|
|
VkDescriptorSetAllocateInfo alloc_info =
|
|
vkb::initializers::descriptor_set_allocate_info(
|
|
descriptor_pool,
|
|
&descriptor_set_layout_bg,
|
|
1);
|
|
|
|
VK_CHECK(vkAllocateDescriptorSets(get_device().get_handle(), &alloc_info, &descriptor_set_bg));
|
|
|
|
|
|
|
|
VkDescriptorImageInfo image_descriptor;
|
|
image_descriptor.imageView = cam_text.view;
|
|
image_descriptor.sampler = cam_text.sampler;
|
|
image_descriptor.imageLayout = cam_text.image_layout;
|
|
|
|
std::vector<VkWriteDescriptorSet> write_descriptor_sets =
|
|
{
|
|
vkb::initializers::write_descriptor_set(
|
|
descriptor_set_bg,
|
|
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
|
|
0,
|
|
&image_descriptor)
|
|
};
|
|
|
|
vkUpdateDescriptorSets(get_device().get_handle(), static_cast<uint32_t>(write_descriptor_sets.size()), write_descriptor_sets.data(), 0, NULL);
|
|
}
|
|
|
|
|
|
void TextureLoading::setup_descriptor_set_layout_point()
|
|
{
|
|
std::vector<VkDescriptorSetLayoutBinding> set_layout_bindings =
|
|
{
|
|
// Binding 0 : Vertex shader uniform buffer
|
|
vkb::initializers::descriptor_set_layout_binding(
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
|
VK_SHADER_STAGE_VERTEX_BIT,
|
|
0),
|
|
// Binding 1 : Fragment shader image sampler
|
|
vkb::initializers::descriptor_set_layout_binding(
|
|
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
|
|
VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
1)
|
|
};
|
|
|
|
VkDescriptorSetLayoutCreateInfo descriptor_layout =
|
|
vkb::initializers::descriptor_set_layout_create_info(
|
|
set_layout_bindings.data(),
|
|
static_cast<uint32_t>(set_layout_bindings.size()));
|
|
|
|
VK_CHECK(vkCreateDescriptorSetLayout(get_device().get_handle(), &descriptor_layout, nullptr, &descriptor_set_layout_point));
|
|
|
|
VkPipelineLayoutCreateInfo pipeline_layout_create_info =
|
|
vkb::initializers::pipeline_layout_create_info(
|
|
&descriptor_set_layout_point,
|
|
1);
|
|
|
|
VkPushConstantRange pushConstantRange{};
|
|
pushConstantRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; // 只在片段着色器中使用
|
|
pushConstantRange.offset = 0;
|
|
pushConstantRange.size = sizeof(float); // 或者 sizeof(PushConstants)
|
|
|
|
pipeline_layout_create_info.pushConstantRangeCount = 1;
|
|
pipeline_layout_create_info.pPushConstantRanges = &pushConstantRange;
|
|
|
|
VK_CHECK(vkCreatePipelineLayout(get_device().get_handle(), &pipeline_layout_create_info, nullptr, &pipeline_layout_point));
|
|
}
|
|
|
|
|
|
void TextureLoading::setup_descriptor_set_point()
|
|
{
|
|
VkDescriptorSetAllocateInfo alloc_info =
|
|
vkb::initializers::descriptor_set_allocate_info(
|
|
descriptor_pool,
|
|
&descriptor_set_layout_point,
|
|
1);
|
|
|
|
VK_CHECK(vkAllocateDescriptorSets(get_device().get_handle(), &alloc_info, &descriptor_set_point));
|
|
|
|
VkDescriptorBufferInfo buffer_descriptor = create_descriptor(*uniform_buffer_vs_point);
|
|
|
|
|
|
VkDescriptorImageInfo image_descriptor;
|
|
image_descriptor.imageView = texture_point.view;
|
|
image_descriptor.sampler = texture_point.sampler;
|
|
image_descriptor.imageLayout = texture_point.image_layout;
|
|
|
|
std::vector<VkWriteDescriptorSet> write_descriptor_sets =
|
|
{
|
|
// Binding 0 : Vertex shader uniform buffer
|
|
vkb::initializers::write_descriptor_set(
|
|
descriptor_set_point,
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
|
0,
|
|
&buffer_descriptor),
|
|
// Binding 1 : Fragment shader texture sampler
|
|
// Fragment shader: layout (binding = 1) uniform sampler2D samplerColor;
|
|
vkb::initializers::write_descriptor_set(
|
|
descriptor_set_point,
|
|
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, // The descriptor set will use a combined image sampler (sampler and image could be split)
|
|
1, // Shader binding point 1
|
|
&image_descriptor) // Pointer to the descriptor image for our texture
|
|
};
|
|
|
|
vkUpdateDescriptorSets(get_device().get_handle(), static_cast<uint32_t>(write_descriptor_sets.size()), write_descriptor_sets.data(), 0, NULL);
|
|
}
|
|
|
|
|
|
void TextureLoading::setup_descriptor_set_layout_point_line()
|
|
{
|
|
std::vector<VkDescriptorSetLayoutBinding> set_layout_bindings =
|
|
{
|
|
// Binding 0 : Vertex shader uniform buffer
|
|
vkb::initializers::descriptor_set_layout_binding(
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
|
VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
0),
|
|
|
|
// Binding 1 : Vertex shader uniform buffer
|
|
vkb::initializers::descriptor_set_layout_binding(
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
|
VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
1),
|
|
|
|
// Binding 2 : Fragment shader image sampler
|
|
vkb::initializers::descriptor_set_layout_binding(
|
|
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
|
|
VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
2)
|
|
};
|
|
|
|
VkDescriptorSetLayoutCreateInfo descriptor_layout =
|
|
vkb::initializers::descriptor_set_layout_create_info(
|
|
set_layout_bindings.data(),
|
|
static_cast<uint32_t>(set_layout_bindings.size()));
|
|
|
|
VK_CHECK(vkCreateDescriptorSetLayout(get_device().get_handle(), &descriptor_layout, nullptr, &descriptor_set_layout_point_line));
|
|
|
|
VkPipelineLayoutCreateInfo pipeline_layout_create_info =
|
|
vkb::initializers::pipeline_layout_create_info(
|
|
&descriptor_set_layout_point_line,
|
|
1);
|
|
|
|
VkPushConstantRange pushConstantRange{};
|
|
pushConstantRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; // 只在片段着色器中使用
|
|
pushConstantRange.offset = 0;
|
|
pushConstantRange.size = sizeof(float); // 或者 sizeof(PushConstants)
|
|
|
|
pipeline_layout_create_info.pushConstantRangeCount = 1;
|
|
pipeline_layout_create_info.pPushConstantRanges = &pushConstantRange;
|
|
|
|
VK_CHECK(vkCreatePipelineLayout(get_device().get_handle(), &pipeline_layout_create_info, nullptr, &pipeline_layout_point_line));
|
|
}
|
|
|
|
|
|
void TextureLoading::setup_descriptor_set_point_line()
|
|
{
|
|
VkDescriptorSetAllocateInfo alloc_info =
|
|
vkb::initializers::descriptor_set_allocate_info(
|
|
descriptor_pool,
|
|
&descriptor_set_layout_point_line,
|
|
1);
|
|
|
|
VK_CHECK(vkAllocateDescriptorSets(get_device().get_handle(), &alloc_info, &descriptor_set_point_line));
|
|
|
|
VkDescriptorBufferInfo buffer_descriptor = create_descriptor(*uniform_buffer_vs_point);
|
|
VkDescriptorBufferInfo buffer_descriptorDashParameters = create_descriptor(*uniform_buffer_DashParameters);
|
|
|
|
|
|
VkDescriptorImageInfo image_descriptor;
|
|
image_descriptor.imageView = texture_point_line.view;
|
|
image_descriptor.sampler = texture_point_line.sampler;
|
|
image_descriptor.imageLayout = texture_point_line.image_layout;
|
|
|
|
std::vector<VkWriteDescriptorSet> write_descriptor_sets =
|
|
{
|
|
// Binding 0 : Vertex shader uniform buffer
|
|
vkb::initializers::write_descriptor_set(
|
|
descriptor_set_point_line,
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
|
0,
|
|
&buffer_descriptor),
|
|
|
|
// Binding 1 : Vertex shader uniform buffer
|
|
vkb::initializers::write_descriptor_set(
|
|
descriptor_set_point_line,
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
|
1,
|
|
&buffer_descriptorDashParameters),
|
|
// Binding 2 : Fragment shader texture sampler
|
|
// Fragment shader: layout (binding = 1) uniform sampler2D samplerColor;
|
|
vkb::initializers::write_descriptor_set(
|
|
descriptor_set_point_line,
|
|
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, // The descriptor set will use a combined image sampler (sampler and image could be split)
|
|
2, // Shader binding point 1
|
|
&image_descriptor) // Pointer to the descriptor image for our texture
|
|
};
|
|
|
|
vkUpdateDescriptorSets(get_device().get_handle(), static_cast<uint32_t>(write_descriptor_sets.size()), write_descriptor_sets.data(), 0, NULL);
|
|
}
|
|
|
|
// Prepare and initialize uniform buffer containing shader uniforms
|
|
void TextureLoading::prepare_uniform_buffers()
|
|
{
|
|
// Vertex shader uniform buffer block
|
|
uniform_buffer_vs = std::make_unique<vkb::core::BufferC>(get_device(),
|
|
sizeof(ubo_vs),
|
|
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
|
|
VMA_MEMORY_USAGE_CPU_TO_GPU);
|
|
|
|
update_uniform_buffers();
|
|
}
|
|
|
|
void TextureLoading::update_uniform_buffers()
|
|
{
|
|
// Vertex shader
|
|
ubo_vs.projection = glm::perspective(glm::radians(60.0f), static_cast<float>(width) / static_cast<float>(height), 0.001f, 256.0f);
|
|
glm::mat4 view_matrix = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, zoom));
|
|
|
|
ubo_vs.model = view_matrix * glm::translate(glm::mat4(1.0f), camera_pos);
|
|
ubo_vs.model = glm::rotate(ubo_vs.model, glm::radians(rotation.x), glm::vec3(1.0f, 0.0f, 0.0f));
|
|
ubo_vs.model = glm::rotate(ubo_vs.model, glm::radians(rotation.y), glm::vec3(0.0f, 1.0f, 0.0f));
|
|
ubo_vs.model = glm::rotate(ubo_vs.model, glm::radians(rotation.z), glm::vec3(0.0f, 0.0f, 1.0f));
|
|
|
|
ubo_vs.view_pos = glm::vec4(0.0f, 0.0f, -zoom, 0.0f);
|
|
|
|
uniform_buffer_vs->convert_and_update(ubo_vs);
|
|
}
|
|
|
|
|
|
void TextureLoading::prepare_uniform_buffers_point()
|
|
{
|
|
uniform_buffer_vs_point = std::make_unique<vkb::core::BufferC>(get_device(),
|
|
sizeof(ubo_vs_point),
|
|
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
|
|
VMA_MEMORY_USAGE_CPU_TO_GPU);
|
|
}
|
|
|
|
void TextureLoading::prepare_uniform_buffers_DashParameters()
|
|
{
|
|
uniform_buffer_DashParameters = std::make_unique<vkb::core::BufferC>(get_device(),
|
|
sizeof(_DashParameters),
|
|
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
|
|
VMA_MEMORY_USAGE_CPU_TO_GPU);
|
|
}
|
|
|
|
void TextureLoading::update_uniform_buffers_DashParameters(float dashSize, float gapSize, float dashOffset, float uAASize, int useWorldSpace)
|
|
{
|
|
if (!prepared)
|
|
{
|
|
return;
|
|
}
|
|
std::unique_lock<std::mutex> lock(mtx_mvp);
|
|
_DashParameters.dashSize = dashSize;
|
|
_DashParameters.gapSize = gapSize;
|
|
_DashParameters.dashOffset = dashOffset;
|
|
_DashParameters.uAASize = uAASize;
|
|
_DashParameters.useWorldSpace = useWorldSpace;
|
|
uniform_buffer_DashParameters->convert_and_update(_DashParameters);
|
|
}
|
|
|
|
|
|
void global_update_mvp(float fov, float x, float y, float z, float sx, float sy, float sz, float rotx, float roty, float rotz, float camx, float camy, float camz, float dashSize, float gapSize, float dashOffset, float uAASize)
|
|
{
|
|
TextureLoading* self = TextureLoading::Get();
|
|
if (self != nullptr)
|
|
{
|
|
self->update_uniform_buffers_point(fov, x, y, z, sx, sy, sz, rotx, roty, rotz, camx, camy, camz);
|
|
self->update_uniform_buffers_DashParameters(dashSize, gapSize, dashOffset, uAASize, 0);
|
|
}
|
|
}
|
|
|
|
void TextureLoading::update_uniform_buffers_point(float fov, float x, float y, float z, float sx, float sy, float sz, float rotx, float roty, float rotz, float camx, float camy, float camz)
|
|
{
|
|
if (!prepared)
|
|
{
|
|
return;
|
|
}
|
|
std::unique_lock<std::mutex> lock(mtx_mvp);
|
|
ubo_vs_point.projection = glm::perspective(glm::radians(fov), static_cast<float>(width) / static_cast<float>(height), 0.001f, 256.0f);
|
|
|
|
//glm::vec3 cameraPos = glm::vec3(camx, camy, camz);
|
|
//glm::vec3 cameraTarget = glm::vec3(0, 0, 0);
|
|
//glm::vec3 cameraUp = glm::vec3(0.0f, 1.0f, 0.0f);
|
|
//ubo_vs_point.view = glm::lookAt(cameraPos, cameraTarget, cameraUp);
|
|
|
|
ubo_vs_point.view = glm::translate(glm::mat4(1.0f), glm::vec3(camx, camy, camz));
|
|
|
|
glm::mat4 model = glm::mat4(1.0f); // 单位矩阵
|
|
|
|
// 1. 先平移
|
|
model = glm::translate(model, glm::vec3(x, y, z));
|
|
|
|
// 2. 然后旋转（注意顺序：通常Z->Y->X或按需求）
|
|
model = glm::rotate(model, glm::radians(rotz), glm::vec3(0.0f, 0.0f, 1.0f)); // Z轴旋转
|
|
model = glm::rotate(model, glm::radians(roty), glm::vec3(0.0f, 1.0f, 0.0f)); // Y轴旋转
|
|
model = glm::rotate(model, glm::radians(rotx), glm::vec3(1.0f, 0.0f, 0.0f)); // X轴旋转
|
|
|
|
// 3. 最后缩放
|
|
model = glm::scale(model, glm::vec3(sx, sy, sz));
|
|
ubo_vs_point.model = model;
|
|
|
|
uniform_buffer_vs_point->convert_and_update(ubo_vs_point);
|
|
}
|
|
|
|
|
|
void TextureLoading::prepare_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(
|
|
// 0xf,
|
|
// VK_FALSE);
|
|
|
|
VkPipelineColorBlendAttachmentState colorBlendAttachment{};
|
|
colorBlendAttachment.blendEnable = VK_TRUE;
|
|
colorBlendAttachment.colorWriteMask =
|
|
VK_COLOR_COMPONENT_R_BIT |
|
|
VK_COLOR_COMPONENT_G_BIT |
|
|
VK_COLOR_COMPONENT_B_BIT |
|
|
VK_COLOR_COMPONENT_A_BIT;
|
|
|
|
// 常用的Alpha混合公式
|
|
colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
|
|
colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
|
colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
|
|
colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
|
|
colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
|
colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
|
|
|
|
//VkPipelineColorBlendStateCreateInfo color_blend_state =
|
|
// vkb::initializers::pipeline_color_blend_state_create_info(
|
|
// 1,
|
|
// &blend_attachment_state);
|
|
|
|
VkPipelineColorBlendStateCreateInfo colorBlending{};
|
|
colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
|
|
colorBlending.logicOpEnable = VK_FALSE;
|
|
colorBlending.attachmentCount = 1;
|
|
colorBlending.pAttachments = &colorBlendAttachment;
|
|
|
|
// Note: Using reversed depth-buffer for increased precision, so Greater depth values are kept
|
|
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 };
|
|
|
|
VkPipelineDynamicStateCreateInfo dynamic_state =
|
|
vkb::initializers::pipeline_dynamic_state_create_info(
|
|
dynamic_state_enables.data(),
|
|
static_cast<uint32_t>(dynamic_state_enables.size()),
|
|
0);
|
|
|
|
// Load shaders
|
|
std::array<VkPipelineShaderStageCreateInfo, 2> shader_stages;
|
|
|
|
shader_stages[0] = load_shader("texture_loading", "texture.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
|
|
shader_stages[1] = load_shader("texture_loading", "texture.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
|
|
|
|
// Vertex bindings and attributes
|
|
const std::vector<VkVertexInputBindingDescription> vertex_input_bindings = {
|
|
vkb::initializers::vertex_input_binding_description(0, sizeof(TextureLoadingVertexStructure), 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(TextureLoadingVertexStructure, pos)),
|
|
vkb::initializers::vertex_input_attribute_description(0, 1, VK_FORMAT_R32G32_SFLOAT, offsetof(TextureLoadingVertexStructure, uv)),
|
|
vkb::initializers::vertex_input_attribute_description(0, 2, VK_FORMAT_R32G32B32_SFLOAT, offsetof(TextureLoadingVertexStructure, normal)),
|
|
};
|
|
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();
|
|
|
|
VkGraphicsPipelineCreateInfo pipeline_create_info =
|
|
vkb::initializers::pipeline_create_info(
|
|
pipeline_layout,
|
|
render_pass,
|
|
0);
|
|
|
|
pipeline_create_info.pVertexInputState = &vertex_input_state;
|
|
pipeline_create_info.pInputAssemblyState = &input_assembly_state;
|
|
pipeline_create_info.pRasterizationState = &rasterization_state;
|
|
pipeline_create_info.pColorBlendState = &colorBlending; //&color_blend_state;
|
|
pipeline_create_info.pMultisampleState = &multisample_state;
|
|
pipeline_create_info.pViewportState = &viewport_state;
|
|
pipeline_create_info.pDepthStencilState = &depth_stencil_state;
|
|
pipeline_create_info.pDynamicState = &dynamic_state;
|
|
pipeline_create_info.stageCount = static_cast<uint32_t>(shader_stages.size());
|
|
pipeline_create_info.pStages = shader_stages.data();
|
|
|
|
VK_CHECK(vkCreateGraphicsPipelines(get_device().get_handle(), pipeline_cache, 1, &pipeline_create_info, nullptr, &pipelines.solid));
|
|
}
|
|
|
|
void TextureLoading::prepare_pipeline_bg()
|
|
{
|
|
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(
|
|
0xf,
|
|
VK_FALSE);
|
|
|
|
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_FALSE,
|
|
VK_FALSE,
|
|
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 };
|
|
|
|
VkPipelineDynamicStateCreateInfo dynamic_state =
|
|
vkb::initializers::pipeline_dynamic_state_create_info(
|
|
dynamic_state_enables.data(),
|
|
static_cast<uint32_t>(dynamic_state_enables.size()),
|
|
0);
|
|
|
|
std::array<VkPipelineShaderStageCreateInfo, 2> shader_stages;
|
|
shader_stages[0] = load_shader("texture_loading", "bg.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
|
|
shader_stages[1] = load_shader("texture_loading", "bg.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
|
|
|
|
VkPipelineVertexInputStateCreateInfo vertex_input_state_bg = vkb::initializers::pipeline_vertex_input_state_create_info();
|
|
|
|
VkGraphicsPipelineCreateInfo pipeline_create_info =
|
|
vkb::initializers::pipeline_create_info(
|
|
pipeline_layout_bg,
|
|
render_pass,
|
|
0);
|
|
|
|
pipeline_create_info.pVertexInputState = &vertex_input_state_bg;
|
|
pipeline_create_info.pInputAssemblyState = &input_assembly_state;
|
|
pipeline_create_info.pRasterizationState = &rasterization_state;
|
|
pipeline_create_info.pColorBlendState = &color_blend_state;
|
|
pipeline_create_info.pMultisampleState = &multisample_state;
|
|
pipeline_create_info.pViewportState = &viewport_state;
|
|
pipeline_create_info.pDepthStencilState = &depth_stencil_state;
|
|
pipeline_create_info.pDynamicState = &dynamic_state;
|
|
pipeline_create_info.stageCount = static_cast<uint32_t>(shader_stages.size());
|
|
pipeline_create_info.pStages = shader_stages.data();
|
|
|
|
VK_CHECK(vkCreateGraphicsPipelines(get_device().get_handle(), pipeline_cache, 1, &pipeline_create_info, nullptr, &pipelines.background));
|
|
}
|
|
|
|
|
|
void TextureLoading::prepare_pipeline_point()
|
|
{
|
|
|
|
// 顶点输入绑定描述 (告诉 Vulkan 顶点数据的格式)
|
|
VkVertexInputBindingDescription vertex_input_binding_description{};
|
|
vertex_input_binding_description.binding = 0; // 绑定点
|
|
vertex_input_binding_description.stride = sizeof(PointVertex); // 每个顶点的字节大小
|
|
vertex_input_binding_description.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
|
|
|
|
// 顶点输入属性描述 (告诉 Vulkan 每个属性在顶点结构中的位置)
|
|
std::array<VkVertexInputAttributeDescription, 2> vertex_input_attributes = {
|
|
VkVertexInputAttributeDescription{0, 0, VK_FORMAT_R32G32B32_SFLOAT, offsetof(PointVertex, x)}, // 位置
|
|
VkVertexInputAttributeDescription{1, 0, VK_FORMAT_R32G32B32_SFLOAT, offsetof(PointVertex, r)} // 颜色
|
|
};
|
|
|
|
VkPipelineVertexInputStateCreateInfo vertex_input_state{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
|
|
vertex_input_state.vertexBindingDescriptionCount = 1;
|
|
vertex_input_state.pVertexBindingDescriptions = &vertex_input_binding_description;
|
|
vertex_input_state.vertexAttributeDescriptionCount = static_cast<uint32_t>(vertex_input_attributes.size());
|
|
vertex_input_state.pVertexAttributeDescriptions = vertex_input_attributes.data();
|
|
|
|
// 输入装配 (绘制点列表)
|
|
VkPipelineInputAssemblyStateCreateInfo input_assembly_state{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO };
|
|
input_assembly_state.topology = VK_PRIMITIVE_TOPOLOGY_POINT_LIST; // 关键：绘制点
|
|
input_assembly_state.primitiveRestartEnable = VK_FALSE;
|
|
|
|
// 光栅化
|
|
VkPipelineRasterizationStateCreateInfo rasterization_state{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO };
|
|
rasterization_state.polygonMode = VK_POLYGON_MODE_FILL;
|
|
rasterization_state.cullMode = VK_CULL_MODE_NONE; // 通常不对点进行剔除
|
|
rasterization_state.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
|
|
rasterization_state.lineWidth = 1.0f; // 可以通过 VkPhysicalDeviceFeatures::wideLines 扩展来支持更宽的线
|
|
|
|
// 视口和裁剪
|
|
VkPipelineViewportStateCreateInfo viewport_state{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO };
|
|
viewport_state.viewportCount = 1;
|
|
viewport_state.scissorCount = 1;
|
|
|
|
|
|
// 多重采样
|
|
VkPipelineMultisampleStateCreateInfo multisample_state{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO };
|
|
multisample_state.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
|
|
|
|
// 深度和模板测试 (通常对点云启用深度测试)
|
|
VkPipelineDepthStencilStateCreateInfo depth_stencil_state{ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO };
|
|
depth_stencil_state.depthTestEnable = VK_FALSE;
|
|
depth_stencil_state.depthWriteEnable = VK_FALSE;
|
|
depth_stencil_state.depthCompareOp = VK_COMPARE_OP_ALWAYS; // 或 VK_COMPARE_OP_LESS
|
|
depth_stencil_state.depthBoundsTestEnable = VK_FALSE;
|
|
depth_stencil_state.stencilTestEnable = VK_FALSE;
|
|
|
|
// 颜色混合 (点通常不需要混合)
|
|
VkPipelineColorBlendAttachmentState blend_attachment_state{};
|
|
blend_attachment_state.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
|
|
blend_attachment_state.blendEnable = VK_FALSE;
|
|
|
|
VkPipelineColorBlendStateCreateInfo color_blend_state{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO };
|
|
color_blend_state.attachmentCount = 1;
|
|
color_blend_state.pAttachments = &blend_attachment_state;
|
|
|
|
// 动态状态 (视口和裁剪矩形将在命令缓冲区中设置)
|
|
std::vector<VkDynamicState> dynamic_state_enables = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
|
|
VkPipelineDynamicStateCreateInfo dynamic_state{ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO };
|
|
dynamic_state.dynamicStateCount = static_cast<uint32_t>(dynamic_state_enables.size());
|
|
dynamic_state.pDynamicStates = dynamic_state_enables.data();
|
|
|
|
// 加载着色器
|
|
std::array<VkPipelineShaderStageCreateInfo, 2> shader_stages;
|
|
shader_stages[0] = load_shader("texture_loading", "pointcloud.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
|
|
shader_stages[1] = load_shader("texture_loading", "pointcloud.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
|
|
|
|
// 创建图形管线
|
|
VkGraphicsPipelineCreateInfo pipeline_create_info{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
|
|
pipeline_create_info.stageCount = static_cast<uint32_t>(shader_stages.size());
|
|
pipeline_create_info.pStages = shader_stages.data();
|
|
pipeline_create_info.pVertexInputState = &vertex_input_state;
|
|
pipeline_create_info.pInputAssemblyState = &input_assembly_state;
|
|
pipeline_create_info.pViewportState = &viewport_state;
|
|
pipeline_create_info.pRasterizationState = &rasterization_state;
|
|
pipeline_create_info.pMultisampleState = &multisample_state;
|
|
pipeline_create_info.pDepthStencilState = &depth_stencil_state;
|
|
pipeline_create_info.pColorBlendState = &color_blend_state;
|
|
pipeline_create_info.pDynamicState = &dynamic_state;
|
|
pipeline_create_info.layout = pipeline_layout_point;
|
|
pipeline_create_info.renderPass = render_pass; // 使用主渲染通道
|
|
pipeline_create_info.subpass = 0; // 主子通道
|
|
|
|
VK_CHECK(vkCreateGraphicsPipelines(get_device().get_handle(), pipeline_cache, 1, &pipeline_create_info, nullptr, &pipelines.point));
|
|
}
|
|
|
|
|
|
void TextureLoading::prepare_pipeline_point_line()
|
|
{
|
|
|
|
// 顶点输入绑定描述 (告诉 Vulkan 顶点数据的格式)
|
|
VkVertexInputBindingDescription vertex_input_binding_description{};
|
|
vertex_input_binding_description.binding = 0; // 绑定点
|
|
vertex_input_binding_description.stride = sizeof(LineVertex); // 每个顶点的字节大小
|
|
vertex_input_binding_description.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
|
|
|
|
// 顶点输入属性描述 (告诉 Vulkan 每个属性在顶点结构中的位置)
|
|
//std::array<VkVertexInputAttributeDescription, 2> vertex_input_attributes = {
|
|
// VkVertexInputAttributeDescription{0, 0, VK_FORMAT_R32G32B32_SFLOAT, offsetof(PointVertex, x)}, // 位置
|
|
// VkVertexInputAttributeDescription{1, 0, VK_FORMAT_R32G32B32_SFLOAT, offsetof(PointVertex, r)} // 颜色
|
|
//};
|
|
|
|
std::array<VkVertexInputAttributeDescription, 4> vertex_input_attributes{};
|
|
|
|
vertex_input_attributes[0] = { 0, 0, VK_FORMAT_R32G32B32_SFLOAT, offsetof(LineVertex, position) };
|
|
vertex_input_attributes[1] = { 1, 0, VK_FORMAT_R32G32B32_SFLOAT, offsetof(LineVertex, color) };
|
|
vertex_input_attributes[2] = { 2, 0, VK_FORMAT_R32G32B32_SFLOAT, offsetof(LineVertex, lineStart) };
|
|
vertex_input_attributes[3] = { 3, 0, VK_FORMAT_R32G32B32_SFLOAT, offsetof(LineVertex, lineEnd) };
|
|
|
|
VkPipelineVertexInputStateCreateInfo vertex_input_state{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
|
|
vertex_input_state.vertexBindingDescriptionCount = 1;
|
|
vertex_input_state.pVertexBindingDescriptions = &vertex_input_binding_description;
|
|
vertex_input_state.vertexAttributeDescriptionCount = static_cast<uint32_t>(vertex_input_attributes.size());
|
|
vertex_input_state.pVertexAttributeDescriptions = vertex_input_attributes.data();
|
|
|
|
// 输入装配 (绘制点列表)
|
|
VkPipelineInputAssemblyStateCreateInfo input_assembly_state{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO };
|
|
input_assembly_state.topology = VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
|
|
input_assembly_state.primitiveRestartEnable = VK_FALSE;
|
|
|
|
// 光栅化
|
|
VkPipelineRasterizationStateCreateInfo rasterization_state{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO };
|
|
rasterization_state.polygonMode = VK_POLYGON_MODE_FILL;
|
|
rasterization_state.cullMode = VK_CULL_MODE_NONE; // 通常不对点进行剔除
|
|
rasterization_state.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
|
|
rasterization_state.lineWidth = 1.0f; // 可以通过 VkPhysicalDeviceFeatures::wideLines 扩展来支持更宽的线
|
|
|
|
// 视口和裁剪
|
|
VkPipelineViewportStateCreateInfo viewport_state{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO };
|
|
viewport_state.viewportCount = 1;
|
|
viewport_state.scissorCount = 1;
|
|
|
|
|
|
// 多重采样
|
|
VkPipelineMultisampleStateCreateInfo multisample_state{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO };
|
|
multisample_state.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
|
|
|
|
// 深度和模板测试 (通常对点云启用深度测试)
|
|
VkPipelineDepthStencilStateCreateInfo depth_stencil_state{ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO };
|
|
depth_stencil_state.depthTestEnable = VK_FALSE;
|
|
depth_stencil_state.depthWriteEnable = VK_FALSE;
|
|
depth_stencil_state.depthCompareOp = VK_COMPARE_OP_ALWAYS; // 或 VK_COMPARE_OP_LESS
|
|
depth_stencil_state.depthBoundsTestEnable = VK_FALSE;
|
|
depth_stencil_state.stencilTestEnable = VK_FALSE;
|
|
|
|
// 颜色混合 (点通常不需要混合)
|
|
VkPipelineColorBlendAttachmentState blend_attachment_state{};
|
|
blend_attachment_state.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
|
|
blend_attachment_state.blendEnable = VK_FALSE;
|
|
|
|
VkPipelineColorBlendStateCreateInfo color_blend_state{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO };
|
|
color_blend_state.attachmentCount = 1;
|
|
color_blend_state.pAttachments = &blend_attachment_state;
|
|
|
|
// 动态状态 (视口和裁剪矩形将在命令缓冲区中设置)
|
|
std::vector<VkDynamicState> dynamic_state_enables = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
|
|
VkPipelineDynamicStateCreateInfo dynamic_state{ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO };
|
|
dynamic_state.dynamicStateCount = static_cast<uint32_t>(dynamic_state_enables.size());
|
|
dynamic_state.pDynamicStates = dynamic_state_enables.data();
|
|
|
|
// 加载着色器
|
|
std::array<VkPipelineShaderStageCreateInfo, 2> shader_stages;
|
|
//shader_stages[0] = load_shader("texture_loading", "point_line.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
|
|
//shader_stages[1] = load_shader("texture_loading", "point_line.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
|
|
shader_stages[0] = load_shader("texture_loading", "point_line.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
|
|
shader_stages[1] = load_shader("texture_loading", "point_line.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
|
|
|
|
// 创建图形管线
|
|
VkGraphicsPipelineCreateInfo pipeline_create_info{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
|
|
pipeline_create_info.stageCount = static_cast<uint32_t>(shader_stages.size());
|
|
pipeline_create_info.pStages = shader_stages.data();
|
|
pipeline_create_info.pVertexInputState = &vertex_input_state;
|
|
pipeline_create_info.pInputAssemblyState = &input_assembly_state;
|
|
pipeline_create_info.pViewportState = &viewport_state;
|
|
pipeline_create_info.pRasterizationState = &rasterization_state;
|
|
pipeline_create_info.pMultisampleState = &multisample_state;
|
|
pipeline_create_info.pDepthStencilState = &depth_stencil_state;
|
|
pipeline_create_info.pColorBlendState = &color_blend_state;
|
|
pipeline_create_info.pDynamicState = &dynamic_state;
|
|
pipeline_create_info.layout = pipeline_layout_point_line;
|
|
pipeline_create_info.renderPass = render_pass; // 使用主渲染通道
|
|
pipeline_create_info.subpass = 0; // 主子通道
|
|
|
|
VK_CHECK(vkCreateGraphicsPipelines(get_device().get_handle(), pipeline_cache, 1, &pipeline_create_info, nullptr, &pipelines.line));
|
|
}
|
|
|
|
|
|
|
|
bool TextureLoading::prepare(const vkb::ApplicationOptions& options)
|
|
{
|
|
if (!ApiVulkanSample::prepare(options))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
last_update_time = getCurrentTimeMillis();
|
|
|
|
myFloatValue = 1.f;
|
|
|
|
// --- 加载前景纹理 (示例) ---
|
|
int width = 640;
|
|
int height = 480;
|
|
int rowStride = width*4;
|
|
auto testImage = generateSimpleTestImage(width, height, 80);
|
|
size_t dataSize = testImage.size();
|
|
processWithVulkan(testImage.data(), width, height, rowStride, dataSize, texture_point, false);
|
|
|
|
|
|
//width = 640;
|
|
//height = 480;
|
|
//rowStride = width * 4;
|
|
//auto arrowImage = generateSimpleTestImage(width, height, 80);
|
|
//dataSize = arrowImage.size();
|
|
//processWithVulkan(arrowImage.data(), width, height, rowStride, dataSize, cam_text);
|
|
|
|
|
|
|
|
#if WIN32
|
|
const char* filename = "assets/out.png";
|
|
std::vector<unsigned char> image;
|
|
unsigned w, h;
|
|
unsigned error = lodepng::decode(image, w, h, filename, LCT_RGBA, 8);
|
|
processWithVulkan(image.data(), w, h, w * 4, image.size(), cam_text, true);
|
|
#else
|
|
const char* filename = "/sdcard/Android/data/com.khronos.vulkan_samples/files/assets/out.png";
|
|
std::vector<unsigned char> image;
|
|
unsigned w, h;
|
|
unsigned error = lodepng::decode(image, w, h, filename, LCT_RGBA, 8);
|
|
processWithVulkan(image.data(), w, h, w*4, image.size(), cam_text, false);
|
|
#endif
|
|
|
|
|
|
width = 256;
|
|
height = 256;
|
|
rowStride = width * 4;
|
|
auto lineImage = generateSimpleTestImage(width, height, 80);
|
|
dataSize = lineImage.size();
|
|
processWithVulkan(lineImage.data(), width, height, rowStride, dataSize, texture_point_line, false);
|
|
#ifdef _WIN32
|
|
const char* filename_test = "assets/DemoHeadBaseColor.png";
|
|
const char* filename_demo1 = "assets/demo1.png";
|
|
const char* filename_demo2 = "assets/demo2.png";
|
|
const char* filename_demo3 = "assets/demo3.png";
|
|
const char* filename_demo4 = "assets/demo4.png";
|
|
#else
|
|
const char* filename_test = "/sdcard/Android/data/com.khronos.vulkan_samples/files/assets/DemoHeadBaseColor.png";
|
|
const char* filename_demo1 = "/sdcard/Android/data/com.khronos.vulkan_samples/files/assets/demo1.png";
|
|
const char* filename_demo2 = "/sdcard/Android/data/com.khronos.vulkan_samples/files/assets/demo2.png";
|
|
const char* filename_demo3 = "/sdcard/Android/data/com.khronos.vulkan_samples/files/assets/demo3.png";
|
|
const char* filename_demo4 = "/sdcard/Android/data/com.khronos.vulkan_samples/files/assets/demo4.png";
|
|
#endif // _WIN32
|
|
|
|
|
|
std::vector<unsigned char> image_test;
|
|
unsigned w_t, h_t;
|
|
unsigned error_t = lodepng::decode(image_test, w_t, h_t, filename_test, LCT_RGBA, 8);
|
|
processWithVulkan(image_test.data(), w_t, h_t, w_t * 4, image_test.size(), texture, true);
|
|
|
|
image_test.clear();
|
|
w_t, h_t;
|
|
error_t = lodepng::decode(image_test, w_t, h_t, filename_demo1, LCT_RGBA, 8);
|
|
processWithVulkan(image_test.data(), w_t, h_t, w_t * 4, image_test.size(), tex_demo1, true);
|
|
|
|
image_test.clear();
|
|
w_t, h_t;
|
|
error_t = lodepng::decode(image_test, w_t, h_t, filename_demo2, LCT_RGBA, 8);
|
|
processWithVulkan(image_test.data(), w_t, h_t, w_t * 4, image_test.size(), tex_demo2, true);
|
|
|
|
image_test.clear();
|
|
w_t, h_t;
|
|
error_t = lodepng::decode(image_test, w_t, h_t, filename_demo3, LCT_RGBA, 8);
|
|
processWithVulkan(image_test.data(), w_t, h_t, w_t * 4, image_test.size(), tex_demo3, true);
|
|
|
|
image_test.clear();
|
|
w_t, h_t;
|
|
error_t = lodepng::decode(image_test, w_t, h_t, filename_demo4, LCT_RGBA, 8);
|
|
processWithVulkan(image_test.data(), w_t, h_t, w_t * 4, image_test.size(), tex_demo4, true);
|
|
|
|
//load_texture();
|
|
|
|
prepare_uniform_buffers();
|
|
prepare_uniform_buffers_point();
|
|
prepare_uniform_buffers_DashParameters();
|
|
|
|
|
|
setup_descriptor_pool();
|
|
|
|
setup_descriptor_set_layout();
|
|
setup_descriptor_set();
|
|
|
|
setup_descriptor_set_layout_bg();
|
|
setup_descriptor_set_bg();
|
|
|
|
|
|
setup_descriptor_set_layout_point_line();
|
|
setup_descriptor_set_point_line();
|
|
|
|
setup_descriptor_set_layout_point();
|
|
setup_descriptor_set_point();
|
|
|
|
prepare_pipelines();
|
|
prepare_pipeline_bg();
|
|
prepare_pipeline_point_line();
|
|
prepare_pipeline_point();
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
//std::ifstream file("face.json");
|
|
//std::string content((std::istreambuf_iterator<char>(file)),std::istreambuf_iterator<char>());
|
|
//nlohmann::json msg = nlohmann::json::parse(content);
|
|
//nlohmann::json rawPoint = msg["data"]["raw_point"];
|
|
//float pos[480 * 3] = { 0 };
|
|
//int pos_id = 0;
|
|
//for (size_t i = 0; i < rawPoint.size(); ++i)
|
|
//{
|
|
// nlohmann::json p = rawPoint[i];
|
|
// int index = p["id"];
|
|
// pos[pos_id++] = p["x"]/480.f;
|
|
// pos[pos_id++] = p["y"] / 480.f;
|
|
// pos[pos_id++] = p["z"];
|
|
//}
|
|
//update_point_vertex_buffer(pos, rawPoint.size());
|
|
//demo1(pos);
|
|
#endif
|
|
|
|
|
|
#ifdef _WIN32
|
|
LoadOBJ("assets/face_929.obj", obj_vertices, obj_indices);
|
|
//std::vector<float> positions_test;
|
|
//LoadOBJ_test("assets/face.obj", positions_test);
|
|
#else
|
|
LoadOBJ("/sdcard/Android/data/com.khronos.vulkan_samples/files/assets/face_929.obj", obj_vertices, obj_indices);
|
|
#endif // _WIN32
|
|
|
|
|
|
generate_quad();
|
|
prepared = true;
|
|
|
|
#ifdef _WIN32
|
|
//for (int i = 0; i < obj_vertices.size(); ++i)
|
|
//{
|
|
// int face_index = obj_vertices_map[i];
|
|
// float x = positions_test[face_index * 3 + 0];
|
|
// float y = positions_test[face_index * 3 + 1];
|
|
// float z = positions_test[face_index * 3 + 2];
|
|
|
|
// float obj_x = obj_vertices[i].pos[0];
|
|
// float obj_y = obj_vertices[i].pos[1];
|
|
// float obj_z = obj_vertices[i].pos[2];
|
|
|
|
// //cout << "index: " << i << " face_index:" << face_index << " diff_x:" << (x - obj_x) << " diff_y:" << (y - obj_y) << " diff_z:" << (z - obj_z) << endl;
|
|
// obj_vertices[i].pos[0] = x;
|
|
// obj_vertices[i].pos[1] = y;
|
|
// obj_vertices[i].pos[2] = z;
|
|
//}
|
|
|
|
//auto vertex_buffer_size = vkb::to_u32(obj_vertices.size() * sizeof(TextureLoadingVertexStructure));
|
|
//vertex_buffer->update(obj_vertices.data(), vertex_buffer_size);
|
|
//update_face_vertex_buffer(positions_test.data(), obj_vertices.size());
|
|
#endif
|
|
|
|
update_uniform_buffers_point(47, -0.5, -0.51, 0, 1, 1, 1, 0, 0, 0, 0, 0, -1);
|
|
//start();
|
|
return true;
|
|
}
|
|
|
|
//void TextureLoading::updateTexture()
|
|
//{
|
|
// std::unique_lock<std::mutex> lock(mtx);
|
|
// std::cout << "Working in thread: " << std::this_thread::get_id() << std::endl;
|
|
// int width = 640;
|
|
// int height = 480;
|
|
// int rowStride;
|
|
// auto testImage = generateSimpleTestImage(width, height, &rowStride);
|
|
// size_t dataSize = testImage.size();
|
|
// processWithVulkan(testImage.data(), width, height, rowStride, dataSize, cam_text);
|
|
//}
|
|
//
|
|
//void TextureLoading::run() {
|
|
// std::this_thread::sleep_for(std::chrono::milliseconds(5000));
|
|
// while (running)
|
|
// {
|
|
// updateTexture();
|
|
// std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
|
// }
|
|
//}
|
|
//
|
|
//void TextureLoading::start() {
|
|
// running = true;
|
|
// // 启动线程执行 run 方法
|
|
// workerThread = std::thread(&TextureLoading::run, this);
|
|
//}
|
|
//
|
|
//void TextureLoading::stop() {
|
|
// running = false;
|
|
// if (workerThread.joinable()) {
|
|
// workerThread.join();
|
|
// }
|
|
//}
|
|
|
|
void ReceiveFacePoint(float* pos, int pointCount, int width, int height)
|
|
{
|
|
//string debug_str = "[";
|
|
//for (int i = 0; i < pointCount; ++i)
|
|
//{
|
|
// debug_str += std::to_string(pos[i * 3 + 0]);
|
|
// debug_str += ",";
|
|
// debug_str += std::to_string(pos[i * 3 + 1]);
|
|
// debug_str += ",";
|
|
// debug_str += std::to_string(pos[i * 3 + 2]);
|
|
// if (pointCount - 1 == i)
|
|
// {
|
|
|
|
// }
|
|
// else {
|
|
// debug_str += ",";
|
|
// }
|
|
//}
|
|
//debug_str += "]";
|
|
|
|
TextureLoading* self = TextureLoading::Get();
|
|
if (self != nullptr)
|
|
{
|
|
TextureLoading::Get()->update_point_vertex_buffer(pos, pointCount);
|
|
TextureLoading::Get()->update_face_vertex_buffer(pos, pointCount);
|
|
//self->demo1(pos);
|
|
}
|
|
|
|
}
|
|
|
|
void TextureLoading::render(float delta_time)
|
|
{
|
|
if (!prepared)
|
|
{
|
|
return;
|
|
}
|
|
#if _WIN32
|
|
string str = "0.497176,0.654941,0.056854,0.499096,0.571142,0.101093,0.499443,0.594826,0.053191,0.486665,0.507695,0.075654,0.499822,0.551577,0.107729,0.501566,0.526343,0.100379,0.507274,0.464574,0.049972,0.384071,0.451689,-0.029412,0.510934,0.411708,0.038101,0.512489,0.385395,0.042231,0.517780,0.303259,0.021708,0.496729,0.663534,0.054564,0.496503,0.672256,0.047820,0.495962,0.678167,0.039046,0.495333,0.708580,0.029263,0.494208,0.719311,0.031647,0.493171,0.732978,0.033173,0.491888,0.745546,0.026135,0.491751,0.757028,0.002595,0.499114,0.582417,0.091598,0.482417,0.582563,0.065089,0.331655,0.382730,-0.120031,0.430957,0.469391,-0.008093,0.414008,0.470789,-0.010267,0.397406,0.470345,-0.016058,0.377172,0.459990,-0.032563,0.445480,0.465845,-0.008916,0.407104,0.414617,-0.002052,0.427153,0.417373,-0.000860,0.388613,0.417688,-0.008829,0.376612,0.425300,-0.017125,0.363639,0.473838,-0.041905,0.424317,0.760712,-0.022355,0.378095,0.447231,-0.035613,0.321751,0.462365,-0.127255,0.346235,0.459834,-0.061681,0.412989,0.556626,0.007719,0.474707,0.648701,0.052639,0.477565,0.671162,0.044046,0.453343,0.656598,0.040157,0.441169,0.666182,0.025390,0.462063,0.673138,0.035794,0.451410,0.677070,0.022132,0.415549,0.701012,-0.009850,0.482972,0.570121,0.099036,0.480842,0.550994,0.104616,0.354530,0.407162,-0.024088,0.450885,0.506449,0.013582,0.439753,0.566562,0.050407,0.438681,0.556687,0.044705,0.367658,0.552965,-0.017865,0.483477,0.527524,0.093462,0.393368,0.385091,0.011027,0.369870,0.392510,-0.004918,0.346767,0.349522,-0.082266,0.471944,0.404162,0.030519,0.443971,0.426069,-0.005504,0.406778,0.677611,-0.012820,0.343144,0.640875,-0.180424,0.453649,0.577968,0.043753,0.469357,0.585499,0.046754,0.428715,0.686186,-0.007846,0.434532,0.686292,-0.001798,0.361692,0.380369,-0.014286,0.439307,0.577039,0.040063,0.426476,0.386744,0.023408,0.423940,0.371093,0.027273,0.414777,0.307725,-0.007059,0.353887,0.365024,-0.043705,0.420427,0.340030,0.011343,0.346111,0.399299,-0.040411,0.338442,0.392337,-0.078127,0.475432,0.660558,0.050712,0.457661,0.665396,0.039118,0.445976,0.671356,0.025472,0.458571,0.583021,0.040336,0.431722,0.686313,-0.004415,0.435878,0.695282,0.004963,0.437489,0.686573,-0.001261,0.462763,0.569201,0.070216,0.456034,0.680024,0.019362,0.466256,0.677225,0.028576,0.479924,0.676736,0.036048,0.464911,0.752547,0.001659,0.466742,0.740062,0.024617,0.469333,0.727902,0.030009,0.473432,0.715088,0.028101,0.477575,0.705166,0.025992,0.454353,0.695796,0.011947,0.448384,0.699739,0.014157,0.441746,0.705512,0.015491,0.436396,0.711411,0.011211,0.424883,0.637143,0.018464,0.325325,0.544807,-0.205772,0.499228,0.588374,0.066624,0.447251,0.691595,0.003838,0.441597,0.693799,0.005282,0.474352,0.594317,0.047149,0.445976,0.590867,0.026735,0.471912,0.590299,0.047519,0.431958,0.518003,0.005830,0.404263,0.531010,-0.001291,0.435866,0.566975,0.033930,0.372888,0.323790,-0.041875,0.379619,0.346958,-0.014714,0.387929,0.370099,0.007512,0.426430,0.717957,-0.004290,0.467216,0.378078,0.038139,0.464274,0.341760,0.026842,0.461524,0.302084,0.014733,0.384502,0.466873,-0.024661,0.346507,0.487632,-0.053234,0.454992,0.460955,-0.011123,0.361290,0.433688,-0.034316,0.464132,0.493651,0.021163,0.450753,0.557678,0.069416,0.330230,0.499824,-0.074338,0.356020,0.501891,-0.036197,0.376221,0.510058,-0.018012,0.408600,0.507543,-0.008056,0.432897,0.499322,-0.002740,0.451626,0.490892,0.003327,0.489139,0.468516,0.041895,0.333081,0.540845,-0.070264,0.349464,0.431355,-0.043972,0.489674,0.581322,0.090078,0.450037,0.526338,0.021342,0.321799,0.461356,-0.190019,0.466393,0.480258,0.006815,0.435159,0.569218,0.014873,0.370473,0.448105,-0.039533,0.450797,0.545711,0.062428,0.330949,0.590338,-0.198092,0.454828,0.454231,-0.016034,0.466584,0.533999,0.081427,0.368977,0.696224,-0.085285,0.371028,0.715130,-0.118389,0.321597,0.542365,-0.137881,0.354546,0.665653,-0.106874,0.329959,0.424926,-0.108036,0.419492,0.778306,-0.034538,0.492124,0.587480,0.065140,0.433445,0.541551,0.013330,0.334037,0.463275,-0.080820,0.399471,0.457458,-0.017688,0.413581,0.458728,-0.012470,0.431282,0.698495,0.001523,0.338871,0.579736,-0.077310,0.448546,0.812289,-0.040055,0.402613,0.769888,-0.073760,0.387343,0.746064,-0.093037,0.514690,0.345274,0.033323,0.488000,0.820705,-0.033467,0.427727,0.457785,-0.010751,0.441068,0.456047,-0.012633,0.450414,0.455453,-0.015941,0.339809,0.428071,-0.063515,0.439953,0.442173,-0.009664,0.425213,0.436909,-0.006777,0.410450,0.434989,-0.008594,0.395831,0.436903,-0.013989,0.386744,0.440697,-0.020517,0.324071,0.418275,-0.159265,0.390377,0.454714,-0.023950,0.498653,0.616235,0.049360,0.438696,0.624162,0.028365,0.453541,0.573481,0.051026,0.471848,0.616528,0.046160,0.509473,0.439198,0.036626,0.383119,0.726852,-0.069040,0.400357,0.751140,-0.052905,0.448261,0.799376,-0.017654,0.357804,0.682843,-0.150576,0.450187,0.449297,-0.013365,0.474411,0.499158,0.047327,0.488080,0.808697,-0.012143,0.421590,0.793239,-0.053836,0.328169,0.584662,-0.136360,0.464164,0.700852,0.019479,0.458453,0.707157,0.021782,0.452413,0.716912,0.022893,0.447621,0.727753,0.018560,0.441569,0.737180,0.001004,0.442923,0.681201,0.009745,0.437506,0.678748,0.009459,0.433157,0.675614,0.009226,0.414865,0.655540,0.003868,0.359632,0.593782,-0.039332,0.476808,0.479702,0.030386,0.470438,0.440075,-0.001203,0.458674,0.442170,-0.009146,0.447241,0.683111,0.007838,0.359273,0.641053,-0.069698,0.486246,0.440059,0.022744,0.433378,0.746332,-0.012836,0.503507,0.505421,0.083170,0.487594,0.488947,0.060638,0.504958,0.485987,0.065768,0.458841,0.529919,0.046526,0.488781,0.790678,-0.001805,0.490518,0.771693,-0.000881,0.459529,0.764384,-0.005205,0.399752,0.700763,-0.023859,0.421744,0.585210,0.009102,0.413708,0.725289,-0.019314,0.390449,0.580406,-0.002206,0.409394,0.606362,0.004826,0.379239,0.612465,-0.018335,0.452143,0.782220,-0.007722,0.447252,0.541647,0.032212,0.386091,0.709841,-0.044705,0.404779,0.735822,-0.036374,0.390113,0.673154,-0.024213,0.345029,0.613400,-0.085212,0.373498,0.668782,-0.044750,0.338735,0.625841,-0.129784,0.399408,0.634678,-0.005042,0.462545,0.512394,0.033459,0.456919,0.565750,0.073789,0.445414,0.572512,0.052962,0.464870,0.552529,0.087854,0.456662,0.419967,0.003821,0.427102,0.406517,0.005780,0.401550,0.403677,0.003182,0.380497,0.407585,-0.005612,0.366728,0.417166,-0.018378,0.360299,0.453843,-0.047318,0.319157,0.501776,-0.133228,0.371666,0.481921,-0.032133,0.388200,0.488065,-0.020028,0.410637,0.487840,-0.011281,0.432495,0.483586,-0.007046,0.449902,0.477569,-0.005056,0.462053,0.471918,-0.003384,0.323676,0.502520,-0.204049,0.446251,0.579433,0.043590,0.472275,0.516499,0.061793,0.469923,0.566576,0.089211,0.481198,0.578090,0.082282,0.470678,0.570257,0.080035,0.451695,0.587196,0.037530,0.483688,0.579992,0.087260,0.486153,0.585274,0.064986,0.461669,0.455214,-0.012452,0.472018,0.460982,-0.000621,0.477589,0.464747,0.012801,0.381748,0.444165,-0.027075,0.369820,0.434840,-0.028560,0.520120,0.509670,0.077569,0.639928,0.465285,-0.016150,0.517380,0.584724,0.066471,0.715554,0.403696,-0.100026,0.590783,0.477515,0.000460,0.607198,0.480811,0.000009,0.624547,0.482151,-0.004264,0.647336,0.474262,-0.018475,0.576117,0.472179,-0.002154,0.619830,0.424470,0.008838,0.599101,0.425106,0.007646,0.638910,0.429879,0.003611,0.650881,0.439135,-0.003648,0.662162,0.489699,-0.026696,0.560030,0.769691,-0.016272,0.646872,0.461100,-0.021607,0.716455,0.484529,-0.106504,0.684725,0.478005,-0.044433,0.596133,0.567597,0.016302,0.520766,0.651431,0.054897,0.515542,0.673358,0.045988,0.541919,0.662133,0.044746,0.554441,0.673315,0.031651,0.531531,0.677956,0.039761,0.543236,0.682623,0.027319,0.577329,0.711360,-0.001842,0.515131,0.572015,0.100255,0.518993,0.553834,0.106169,0.677453,0.423590,-0.008011,0.563336,0.512941,0.019279,0.564279,0.574269,0.055779,0.566811,0.564718,0.050342,0.646290,0.568883,-0.003657,0.519468,0.529384,0.095423,0.635524,0.395683,0.022401,0.660811,0.406598,0.009193,0.699735,0.368182,-0.064351,0.551948,0.406547,0.034263,0.581497,0.431749,0.001411,0.589114,0.688159,-0.003169,0.677339,0.660422,-0.161864,0.548818,0.583685,0.047779,0.532009,0.589124,0.048746,0.566879,0.695510,0.000392,0.561139,0.694875,0.005586,0.671557,0.395433,0.000750,0.564795,0.584796,0.045456,0.600293,0.393871,0.031245,0.604306,0.378296,0.035326,0.625639,0.318594,0.003472,0.685322,0.382141,-0.027171,0.613096,0.349371,0.020430,0.688210,0.416882,-0.023606,0.701864,0.411915,-0.059446,0.518584,0.663321,0.052861,0.536769,0.670465,0.043372,0.549341,0.678211,0.031193,0.544084,0.587934,0.043605,0.564634,0.695251,0.003240,0.558536,0.704098,0.011482,0.558584,0.694747,0.005856,0.538829,0.573424,0.073854,0.538066,0.684949,0.024283,0.527404,0.681348,0.032242,0.512870,0.679137,0.038064,0.519139,0.755499,0.003671,0.518486,0.743786,0.026903,0.517634,0.731575,0.032250,0.516113,0.717844,0.030494,0.513420,0.708511,0.028220,0.539353,0.701737,0.016899,0.544395,0.706313,0.019210,0.550164,0.713512,0.020773,0.555166,0.720026,0.016870,0.572683,0.645528,0.025733,0.710030,0.567562,-0.184627,0.547799,0.698297,0.009966,0.552628,0.701337,0.011608,0.525599,0.597337,0.049125,0.556687,0.598083,0.031061,0.528567,0.593943,0.049423,0.582289,0.526249,0.013291,0.609304,0.542779,0.008762,0.569631,0.575154,0.039721,0.671492,0.339204,-0.027124,0.657767,0.360742,-0.001246,0.643095,0.381494,0.019428,0.563003,0.726708,0.002365,0.558594,0.380698,0.042151,0.566732,0.346787,0.031789,0.575973,0.307779,0.019911,0.638921,0.479888,-0.011529,0.680104,0.506291,-0.036422,0.567154,0.466710,-0.005030,0.667807,0.449921,-0.018832,0.550147,0.498595,0.025793,0.551850,0.563974,0.073770,0.698622,0.520703,-0.056037,0.666594,0.519332,-0.020402,0.642671,0.525317,-0.004680,0.608893,0.518557,0.002099,0.584730,0.507539,0.005064,0.565693,0.496641,0.009221,0.525270,0.470289,0.043947,0.689720,0.561844,-0.051289,0.682081,0.449040,-0.027038,0.508370,0.582191,0.091036,0.561341,0.532878,0.026843,0.722118,0.483905,-0.168103,0.551568,0.484314,0.011533,0.571334,0.577608,0.020740,0.655745,0.462946,-0.024868,0.554447,0.552057,0.066893,0.698238,0.612234,-0.178164,0.567927,0.459930,-0.009761,0.537288,0.538458,0.084675,0.632147,0.712626,-0.070805,0.631425,0.731063,-0.104205,0.708065,0.564654,-0.117313,0.653631,0.683332,-0.089901,0.709937,0.446087,-0.088208,0.563700,0.788143,-0.027752,0.506608,0.587999,0.065732,0.577317,0.550120,0.020060,0.699288,0.482938,-0.062662,0.622400,0.468586,-0.006056,0.608608,0.468353,-0.002165,0.563362,0.707131,0.008588,0.679961,0.599426,-0.058863,0.529228,0.818271,-0.036302,0.586102,0.782835,-0.064767,0.607442,0.760490,-0.081599,0.594157,0.466182,-0.002041,0.581561,0.463268,-0.005113,0.572854,0.461417,-0.009229,0.695451,0.446951,-0.045060,0.583458,0.448689,-0.001909,0.598850,0.444863,0.002287,0.614531,0.445195,0.001993,0.628708,0.448975,-0.002102,0.638063,0.454161,-0.007812,0.722382,0.440050,-0.138154,0.632341,0.467407,-0.011427,0.559611,0.631257,0.033997,0.548870,0.579269,0.054880,0.525722,0.619836,0.048493,0.611235,0.741212,-0.057593,0.588662,0.763930,-0.043926,0.529641,0.805579,-0.013950,0.653161,0.700565,-0.133655,0.573097,0.454888,-0.006403,0.536101,0.502899,0.050517,0.560977,0.803411,-0.047012,0.695693,0.606590,-0.116395,0.528442,0.705387,0.023332,0.532238,0.712963,0.025645,0.537150,0.723772,0.027100,0.540330,0.734254,0.022970,0.545016,0.743686,0.005916,0.552721,0.688764,0.016160,0.557956,0.686471,0.016583,0.562730,0.684328,0.016763,0.582108,0.665690,0.012731,0.652568,0.610692,-0.024044,0.537377,0.482965,0.033562,0.552371,0.443228,0.002903,0.565118,0.446780,-0.003220,0.547636,0.689476,0.014027,0.648242,0.658063,-0.053998,0.533559,0.441745,0.025209,0.552603,0.753907,-0.007422,0.522843,0.491058,0.062317,0.549125,0.535002,0.050448,0.522652,0.768990,-0.002450,0.594508,0.712875,-0.014648,0.583565,0.594997,0.016242,0.576379,0.735216,-0.011804,0.617739,0.593849,0.008780,0.594202,0.617152,0.013655,0.626712,0.626660,-0.005683,0.527749,0.787587,-0.004351,0.561398,0.548432,0.037376,0.607854,0.723607,-0.033930,0.584988,0.747213,-0.027949,0.607137,0.685510,-0.013096,0.669223,0.632014,-0.067645,0.627381,0.684162,-0.031626,0.678666,0.645903,-0.110840,0.601086,0.646556,0.005274,0.548538,0.517258,0.037911,0.544143,0.570758,0.077744,0.557145,0.579607,0.057561,0.536327,0.556903,0.091150,0.568297,0.424490,0.009520,0.599297,0.413819,0.014083,0.625785,0.414205,0.013963,0.647781,0.420823,0.007414,0.661941,0.432020,-0.003774,0.667822,0.470236,-0.031640,0.714666,0.524582,-0.112061,0.651834,0.497336,-0.017913,0.632866,0.501171,-0.007662,0.609142,0.498461,-0.001143,0.587206,0.491510,0.000973,0.570245,0.483593,0.000986,0.557426,0.476755,0.001619,0.717041,0.525139,-0.182401,0.556791,0.586069,0.048235,0.535028,0.519947,0.064947,0.529718,0.570055,0.091877,0.518192,0.580142,0.083682,0.529499,0.573941,0.082695,0.551106,0.593469,0.041341,0.514593,0.581485,0.088573,0.513056,0.587428,0.066045,0.560480,0.459829,-0.007225,0.548299,0.464467,0.003353,0.541220,0.467790,0.016204,0.643205,0.458092,-0.013781,0.658050,0.449765,-0.014260,0.412286,0.445339,-0.001516,0.430124,0.445958,-0.001554,0.412898,0.429588,-0.001565,0.394553,0.444505,-0.001557,0.411734,0.461423,-0.001548,0.609282,0.455161,0.000551,0.627642,0.456293,0.000596,0.610426,0.439139,0.000597,0.590772,0.453523,0.000621,0.607511,0.470991,0.000620";
|
|
|
|
std::vector<float> floatArray;
|
|
|
|
std::stringstream ss(str);
|
|
std::string token;
|
|
|
|
while (std::getline(ss, token, ',')) {
|
|
floatArray.push_back(std::stof(token));
|
|
}
|
|
|
|
ReceiveFacePoint(floatArray.data(), floatArray.size() / 3, 480, 480);
|
|
|
|
#endif
|
|
draw();
|
|
}
|
|
|
|
void TextureLoading::view_changed()
|
|
{
|
|
update_uniform_buffers();
|
|
}
|
|
|
|
void TextureLoading::input_event(const vkb::InputEvent& input_event)
|
|
{
|
|
ApiVulkanSample::input_event(input_event);
|
|
if (input_event.get_source() == vkb::EventSource::Touchscreen)
|
|
{
|
|
const auto& touch_event = static_cast<const vkb::TouchInputEvent&>(input_event);
|
|
|
|
if (touch_event.get_action() == vkb::TouchAction::Down)
|
|
{
|
|
|
|
}
|
|
else if (touch_event.get_action() == vkb::TouchAction::Up)
|
|
{
|
|
if (cur_texture == "texture")
|
|
{
|
|
update_texture(tex_demo1);
|
|
cur_texture = "tex_demo1";
|
|
}
|
|
else if (cur_texture == "tex_demo1")
|
|
{
|
|
update_texture(tex_demo2);
|
|
cur_texture = "tex_demo2";
|
|
}
|
|
else if (cur_texture == "tex_demo2")
|
|
{
|
|
update_texture(tex_demo3);
|
|
cur_texture = "tex_demo3";
|
|
}
|
|
else if (cur_texture == "tex_demo3")
|
|
{
|
|
update_texture(tex_demo4);
|
|
cur_texture = "tex_demo4";
|
|
}
|
|
else if (cur_texture == "tex_demo4")
|
|
{
|
|
update_texture(texture);
|
|
cur_texture = "texture";
|
|
}
|
|
}
|
|
}
|
|
|
|
if (input_event.get_source() == vkb::EventSource::Mouse)
|
|
{
|
|
const auto& touch_event = static_cast<const vkb::MouseButtonInputEvent&>(input_event);
|
|
if (touch_event.get_action() == vkb::MouseAction::Up)
|
|
{
|
|
if (cur_texture == "texture")
|
|
{
|
|
update_texture(tex_demo1);
|
|
cur_texture = "tex_demo1";
|
|
}
|
|
else if (cur_texture == "tex_demo1")
|
|
{
|
|
update_texture(tex_demo2);
|
|
cur_texture = "tex_demo2";
|
|
}
|
|
else if (cur_texture == "tex_demo2")
|
|
{
|
|
update_texture(tex_demo3);
|
|
cur_texture = "tex_demo3";
|
|
}
|
|
else if (cur_texture == "tex_demo3")
|
|
{
|
|
update_texture(tex_demo4);
|
|
cur_texture = "tex_demo4";
|
|
}
|
|
else if (cur_texture == "tex_demo4")
|
|
{
|
|
update_texture(texture);
|
|
cur_texture = "texture";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TextureLoading::on_update_ui_overlay(vkb::Drawer& drawer)
|
|
{
|
|
if (drawer.header("Settings"))
|
|
{
|
|
if (drawer.slider_float("LOD bias", &ubo_vs.lod_bias, 0.0f, static_cast<float>(texture.mip_levels)))
|
|
{
|
|
update_uniform_buffers();
|
|
}
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<vkb::Application> create_texture_loading()
|
|
{
|
|
return std::make_unique<TextureLoading>();
|
|
}
|
|
|
|
TextureLoading* TextureLoading::this_instance = nullptr;
|
|
|
|
void TextureLoadProcessWithVulkan(uint8_t* data, int width, int height, int rowStride, size_t dataSize)
|
|
{
|
|
TextureLoading::Texture& cam_tex = TextureLoading::Get()->cam_text;
|
|
TextureLoading::Get()->processWithVulkan(data, width, height, rowStride, dataSize, cam_tex, false);
|
|
}
|
|
|
|
|
|
|
|
void TextureLoading::extendPoint(float* pos, int start_id, int end_id, float rate)
|
|
{
|
|
glm::vec3 start = glm::vec3(pos[start_id * 3], pos[start_id * 3 + 1], pos[start_id * 3 + 2]);
|
|
glm::vec3 end = glm::vec3(pos[end_id * 3], pos[end_id * 3 + 1], pos[end_id * 3 + 2]);
|
|
glm::vec3 dir = end - start;
|
|
glm::vec3 ex_end = end + dir * rate;
|
|
pos[end_id * 3 + 0] = ex_end.x;
|
|
pos[end_id * 3 + 1] = ex_end.y;
|
|
pos[end_id * 3 + 2] = ex_end.z;
|
|
}
|
|
|
|
void TextureLoading::update_face_vertex_buffer(float* pos, int pointCount)
|
|
{
|
|
if (!prepared)
|
|
{
|
|
return;
|
|
}
|
|
|
|
std::lock_guard<std::mutex> lock(mtx_point);
|
|
last_update_time = getCurrentTimeMillis();
|
|
|
|
extendPoint(pos, 68, 54);
|
|
extendPoint(pos, 104, 103);
|
|
extendPoint(pos, 69, 67);
|
|
extendPoint(pos, 108, 109);
|
|
extendPoint(pos, 151, 10);
|
|
extendPoint(pos, 337, 338);
|
|
extendPoint(pos, 299, 297);
|
|
extendPoint(pos, 333, 332);
|
|
extendPoint(pos, 298, 284);
|
|
|
|
for (int i = 0; i < obj_vertices.size(); ++i)
|
|
{
|
|
int face_index = obj_vertices_map[i];
|
|
float x = pos[face_index * 3 + 0];
|
|
float y = pos[face_index * 3 + 1];
|
|
float z = pos[face_index * 3 + 2];
|
|
|
|
obj_vertices[i].pos[0] = x;
|
|
obj_vertices[i].pos[1] = y;
|
|
obj_vertices[i].pos[2] = z;
|
|
}
|
|
|
|
auto vertex_buffer_size = vkb::to_u32(obj_vertices.size() * sizeof(TextureLoadingVertexStructure));
|
|
vertex_buffer->update(obj_vertices.data(), vertex_buffer_size);
|
|
}
|
|
|
|
void TextureLoading::processWithVulkan(uint8_t* data, int width, int height, int rowStride, size_t dataSize, Texture& out_texture, bool srgb)
|
|
{
|
|
std::unique_lock<std::mutex> lock(mtx);
|
|
VkDevice& device = get_device().get_handle();
|
|
const VkPhysicalDevice& physicalDevice = get_device().get_gpu().get_handle();
|
|
if (out_texture.image == VK_NULL_HANDLE)
|
|
{
|
|
createTexture(device, physicalDevice, width, height, out_texture, srgb);
|
|
|
|
}
|
|
|
|
const VkCommandPool& commandPool = get_device().get_command_pool().get_handle();
|
|
updateTexture(device, physicalDevice, commandPool, queue, data, width, height,
|
|
rowStride, dataSize, out_texture);
|
|
// 如果纹理被更新，并且管线已经准备好，可能需要重建命令缓冲区
|
|
// 这取决于你的应用逻辑。简单起见，在外部函数中处理。
|
|
}
|
|
|
|
// --- 以下函数保持不变 ---
|
|
void TextureLoading::createTexture(VkDevice device, VkPhysicalDevice physicalDevice, int width, int height, Texture& texture, bool srgb)
|
|
{
|
|
texture.width = width;
|
|
texture.height = height;
|
|
texture.mip_levels = 1;
|
|
|
|
VkImageCreateInfo imageInfo = {};
|
|
imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
imageInfo.imageType = VK_IMAGE_TYPE_2D;
|
|
if (srgb)
|
|
{
|
|
imageInfo.format = VK_FORMAT_R8G8B8A8_SRGB;
|
|
}
|
|
else
|
|
{
|
|
imageInfo.format = VK_FORMAT_R8G8B8A8_UNORM;// VK_FORMAT_R8G8B8A8_SRGB; //VK_FORMAT_R8G8B8A8_UNORM;
|
|
}
|
|
imageInfo.extent.width = width;
|
|
imageInfo.extent.height = height;
|
|
imageInfo.extent.depth = 1;
|
|
imageInfo.mipLevels = 1;
|
|
imageInfo.arrayLayers = 1;
|
|
imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
imageInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
|
|
if (vkCreateImage(device, &imageInfo, nullptr, &texture.image) != VK_SUCCESS)
|
|
{
|
|
throw std::runtime_error("Failed to create image!");
|
|
}
|
|
|
|
VkMemoryRequirements memRequirements;
|
|
vkGetImageMemoryRequirements(device, texture.image, &memRequirements);
|
|
|
|
VkMemoryAllocateInfo allocInfo = {};
|
|
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
|
allocInfo.allocationSize = memRequirements.size;
|
|
allocInfo.memoryTypeIndex = findMemoryType(physicalDevice,
|
|
memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
|
|
|
if (vkAllocateMemory(device, &allocInfo, nullptr, &texture.device_memory) != VK_SUCCESS)
|
|
{
|
|
throw std::runtime_error("Failed to allocate image memory!");
|
|
}
|
|
|
|
vkBindImageMemory(device, texture.image, texture.device_memory, 0);
|
|
|
|
VkImageViewCreateInfo viewInfo = {};
|
|
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
|
viewInfo.image = texture.image;
|
|
viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
|
if (srgb)
|
|
{
|
|
viewInfo.format = VK_FORMAT_R8G8B8A8_SRGB;
|
|
}
|
|
else
|
|
{
|
|
viewInfo.format = VK_FORMAT_R8G8B8A8_UNORM;// VK_FORMAT_R8G8B8A8_SRGB; // VK_FORMAT_R8G8B8A8_UNORM;
|
|
}
|
|
viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
viewInfo.subresourceRange.baseMipLevel = 0;
|
|
viewInfo.subresourceRange.levelCount = 1;
|
|
viewInfo.subresourceRange.baseArrayLayer = 0;
|
|
viewInfo.subresourceRange.layerCount = 1;
|
|
|
|
if (vkCreateImageView(device, &viewInfo, nullptr, &texture.view) != VK_SUCCESS)
|
|
{
|
|
throw std::runtime_error("Failed to create texture image view!");
|
|
}
|
|
|
|
VkSamplerCreateInfo samplerInfo = {};
|
|
samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
|
|
samplerInfo.magFilter = VK_FILTER_LINEAR;
|
|
samplerInfo.minFilter = VK_FILTER_LINEAR;
|
|
samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
samplerInfo.anisotropyEnable = VK_FALSE;
|
|
samplerInfo.maxAnisotropy = 1.0f;
|
|
samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
|
|
samplerInfo.unnormalizedCoordinates = VK_FALSE;
|
|
samplerInfo.compareEnable = VK_FALSE;
|
|
samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS;
|
|
samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
|
|
samplerInfo.mipLodBias = 0.0f;
|
|
samplerInfo.minLod = 0.0f;
|
|
samplerInfo.maxLod = 0.0f;
|
|
|
|
if (vkCreateSampler(device, &samplerInfo, nullptr, &texture.sampler) != VK_SUCCESS)
|
|
{
|
|
throw std::runtime_error("Failed to create texture sampler!");
|
|
}
|
|
|
|
texture.image_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
|
}
|
|
|
|
void TextureLoading::updateTexture(VkDevice device, VkPhysicalDevice physicalDevice,
|
|
VkCommandPool commandPool, VkQueue queue,
|
|
uint8_t* data, int width, int height,
|
|
int rowStride, size_t dataSize, Texture& texture)
|
|
{
|
|
VkBuffer stagingBuffer;
|
|
VkDeviceMemory stagingBufferMemory;
|
|
|
|
VkBufferCreateInfo bufferInfo = {};
|
|
bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
|
|
bufferInfo.size = dataSize;
|
|
bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
|
|
bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
|
|
if (vkCreateBuffer(device, &bufferInfo, nullptr, &stagingBuffer) != VK_SUCCESS)
|
|
{
|
|
throw std::runtime_error("Failed to create staging buffer!");
|
|
}
|
|
|
|
VkMemoryRequirements memRequirements;
|
|
vkGetBufferMemoryRequirements(device, stagingBuffer, &memRequirements);
|
|
|
|
VkMemoryAllocateInfo allocInfo = {};
|
|
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
|
allocInfo.allocationSize = memRequirements.size;
|
|
allocInfo.memoryTypeIndex = findMemoryType(physicalDevice,
|
|
memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
|
|
|
if (vkAllocateMemory(device, &allocInfo, nullptr, &stagingBufferMemory) != VK_SUCCESS)
|
|
{
|
|
throw std::runtime_error("Failed to allocate staging buffer memory!");
|
|
}
|
|
|
|
vkBindBufferMemory(device, stagingBuffer, stagingBufferMemory, 0);
|
|
|
|
void* mappedData;
|
|
vkMapMemory(device, stagingBufferMemory, 0, dataSize, 0, &mappedData);
|
|
|
|
if (rowStride == width * 4)
|
|
{
|
|
memcpy(mappedData, data, dataSize);
|
|
}
|
|
else
|
|
{
|
|
uint8_t* dst = static_cast<uint8_t*>(mappedData);
|
|
const uint8_t* src = data;
|
|
size_t dstRowStride = width * 4;
|
|
|
|
for (int y = 0; y < height; y++)
|
|
{
|
|
memcpy(dst, src, dstRowStride);
|
|
dst += dstRowStride;
|
|
src += rowStride;
|
|
}
|
|
}
|
|
|
|
vkUnmapMemory(device, stagingBufferMemory);
|
|
|
|
VkCommandBuffer commandBuffer = beginSingleTimeCommands(device, commandPool);
|
|
|
|
transitionImageLayout(commandBuffer, texture.image,
|
|
VK_IMAGE_LAYOUT_UNDEFINED,
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
|
|
|
|
VkBufferImageCopy region = {};
|
|
region.bufferOffset = 0;
|
|
region.bufferRowLength = 0;
|
|
region.bufferImageHeight = 0;
|
|
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
region.imageSubresource.mipLevel = 0;
|
|
region.imageSubresource.baseArrayLayer = 0;
|
|
region.imageSubresource.layerCount = 1;
|
|
region.imageOffset = { 0, 0, 0 };
|
|
region.imageExtent = { static_cast<uint32_t>(width),
|
|
static_cast<uint32_t>(height), 1 };
|
|
|
|
vkCmdCopyBufferToImage(commandBuffer, stagingBuffer, texture.image,
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion);
|
|
|
|
transitionImageLayout(commandBuffer, texture.image,
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
|
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
|
|
|
|
endSingleTimeCommands(device, commandPool, queue, commandBuffer);
|
|
|
|
vkDestroyBuffer(device, stagingBuffer, nullptr);
|
|
vkFreeMemory(device, stagingBufferMemory, nullptr);
|
|
|
|
texture.image_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
|
}
|
|
|
|
uint32_t TextureLoading::findMemoryType(VkPhysicalDevice physicalDevice, uint32_t typeFilter,
|
|
VkMemoryPropertyFlags properties)
|
|
{
|
|
VkPhysicalDeviceMemoryProperties memProperties;
|
|
vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProperties);
|
|
|
|
for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++)
|
|
{
|
|
if ((typeFilter & (1 << i)) &&
|
|
(memProperties.memoryTypes[i].propertyFlags & properties) == properties)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
|
|
throw std::runtime_error("Failed to find suitable memory type!");
|
|
}
|
|
|
|
VkCommandBuffer TextureLoading::beginSingleTimeCommands(VkDevice device, VkCommandPool commandPool)
|
|
{
|
|
VkCommandBufferAllocateInfo allocInfo = {};
|
|
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
|
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
|
allocInfo.commandPool = commandPool;
|
|
allocInfo.commandBufferCount = 1;
|
|
|
|
VkCommandBuffer commandBuffer;
|
|
vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer);
|
|
|
|
VkCommandBufferBeginInfo beginInfo = {};
|
|
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
|
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
|
|
|
vkBeginCommandBuffer(commandBuffer, &beginInfo);
|
|
|
|
return commandBuffer;
|
|
}
|
|
|
|
void TextureLoading::endSingleTimeCommands(VkDevice device, VkCommandPool commandPool,
|
|
VkQueue queue, VkCommandBuffer commandBuffer)
|
|
{
|
|
vkEndCommandBuffer(commandBuffer);
|
|
|
|
VkSubmitInfo submitInfo = {};
|
|
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
|
submitInfo.commandBufferCount = 1;
|
|
submitInfo.pCommandBuffers = &commandBuffer;
|
|
|
|
vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
|
|
vkQueueWaitIdle(queue);
|
|
|
|
vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer);
|
|
}
|
|
|
|
void TextureLoading::transitionImageLayout(VkCommandBuffer commandBuffer, VkImage image,
|
|
VkImageLayout oldLayout, VkImageLayout newLayout)
|
|
{
|
|
VkImageMemoryBarrier barrier = {};
|
|
barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
|
|
barrier.oldLayout = oldLayout;
|
|
barrier.newLayout = newLayout;
|
|
barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
|
barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
|
barrier.image = image;
|
|
barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
barrier.subresourceRange.baseMipLevel = 0;
|
|
barrier.subresourceRange.levelCount = 1;
|
|
barrier.subresourceRange.baseArrayLayer = 0;
|
|
barrier.subresourceRange.layerCount = 1;
|
|
|
|
VkPipelineStageFlags sourceStage;
|
|
VkPipelineStageFlags destinationStage;
|
|
|
|
if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED &&
|
|
newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL)
|
|
{
|
|
barrier.srcAccessMask = 0;
|
|
barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
|
|
|
sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
|
|
destinationStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
|
|
}
|
|
else if (oldLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL &&
|
|
newLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
|
|
{
|
|
barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
|
barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
|
|
|
|
sourceStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
|
|
destinationStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
|
|
}
|
|
else
|
|
{
|
|
throw std::invalid_argument("Unsupported layout transition!");
|
|
}
|
|
|
|
vkCmdPipelineBarrier(commandBuffer, sourceStage, destinationStage, 0,
|
|
0, nullptr, 0, nullptr, 1, &barrier);
|
|
}
|
|
|
|
//void TextureLoading::setup_point_descriptor_set_layout()
|
|
//{
|
|
// // --- 修改：为点云 UBO 创建描述符集布局绑定，指向 binding 0 ---
|
|
// VkDescriptorSetLayoutBinding ubo_layout_binding{};
|
|
// ubo_layout_binding.binding = 0; // 与着色器中的 layout(binding = 0) 匹配
|
|
// ubo_layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
|
// ubo_layout_binding.descriptorCount = 1;
|
|
// ubo_layout_binding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; // 仅在顶点着色器中使用
|
|
// ubo_layout_binding.pImmutableSamplers = nullptr;
|
|
//
|
|
// VkDescriptorSetLayoutCreateInfo layout_info{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO };
|
|
// layout_info.bindingCount = 1;
|
|
// layout_info.pBindings = &ubo_layout_binding; // 指向我们的 UBO 绑定
|
|
//
|
|
// VK_CHECK(vkCreateDescriptorSetLayout(get_device().get_handle(), &layout_info, nullptr, &point_descriptor_set_layout));
|
|
// // --- 修改结束 ---
|
|
//}
|
|
//
|
|
//void TextureLoading::setup_point_descriptor_set()
|
|
//{
|
|
// // --- 修改：分配点云描述符集 ---
|
|
// VkDescriptorSetAllocateInfo alloc_info{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO };
|
|
// alloc_info.descriptorPool = descriptor_pool; // 使用您已有的描述符池
|
|
// alloc_info.descriptorSetCount = 1;
|
|
// alloc_info.pSetLayouts = &point_descriptor_set_layout;
|
|
//
|
|
// VK_CHECK(vkAllocateDescriptorSets(get_device().get_handle(), &alloc_info, &point_descriptor_set));
|
|
// // --- 修改结束 ---
|
|
//
|
|
// // --- 新增：更新点云描述符集，指向已有的 uniform_buffer_vs ---
|
|
// update_point_descriptor_set(); // 调用辅助函数进行更新
|
|
// // --- 新增结束 ---
|
|
//}
|
|
|
|
|
|
|
|
|
|
void TextureLoading::update_point_vertex_buffer(float* pos, int pointCount)
|
|
{
|
|
if (!prepared)
|
|
{
|
|
return;
|
|
}
|
|
|
|
std::lock_guard<std::mutex> lock(mtx_point);
|
|
if (pointCount <= 0) {
|
|
point_count = 0;
|
|
return; // 没有点数据，无需更新
|
|
}
|
|
|
|
point_count = pointCount;
|
|
|
|
// 1. 准备顶点数据
|
|
std::vector<PointVertex> vertices(point_count);
|
|
// 假设 pos 数组是 [x0,y0,z0,x1,y1,z1,...]
|
|
// 为了可视化，这里简单地将坐标映射为颜色 (0-1范围)
|
|
float min_x = std::numeric_limits<float>::max(), max_x = std::numeric_limits<float>::lowest();
|
|
float min_y = std::numeric_limits<float>::max(), max_y = std::numeric_limits<float>::lowest();
|
|
float min_z = std::numeric_limits<float>::max(), max_z = std::numeric_limits<float>::lowest();
|
|
|
|
for (int i = 0; i < point_count; ++i) {
|
|
float x = pos[i * 3 + 0];
|
|
float y = pos[i * 3 + 1];
|
|
float z = pos[i * 3 + 2];
|
|
min_x = std::min(min_x, x); max_x = std::max(max_x, x);
|
|
min_y = std::min(min_y, y); max_y = std::max(max_y, y);
|
|
min_z = std::min(min_z, z); max_z = std::max(max_z, z);
|
|
}
|
|
float range_x = max_x - min_x;
|
|
float range_y = max_y - min_y;
|
|
float range_z = max_z - min_z;
|
|
if (range_x == 0) range_x = 1.0f; // 防止除零
|
|
if (range_y == 0) range_y = 1.0f;
|
|
if (range_z == 0) range_z = 1.0f;
|
|
|
|
for (int i = 0; i < point_count; ++i) {
|
|
vertices[i].x = pos[i * 3 + 0];
|
|
vertices[i].y = pos[i * 3 + 1];
|
|
vertices[i].z = pos[i * 3 + 2];
|
|
// 简单颜色映射
|
|
vertices[i].r = (vertices[i].x - min_x) / range_x;
|
|
vertices[i].g = (vertices[i].y - min_y) / range_y;
|
|
vertices[i].b = (vertices[i].z - min_z) / range_z;
|
|
}
|
|
|
|
// 2. 更新或创建顶点缓冲区
|
|
VkDeviceSize buffer_size = sizeof(PointVertex) * point_count;
|
|
|
|
if (!vertex_buffer_point || vertex_buffer_point->get_size() < buffer_size) {
|
|
// 如果缓冲区不存在或太小，则重新创建
|
|
vertex_buffer_point.reset();
|
|
vertex_buffer_point = std::make_unique<vkb::core::BufferC>(get_device(),
|
|
buffer_size,
|
|
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
|
|
VMA_MEMORY_USAGE_CPU_TO_GPU // CPU 可写，GPU 可读
|
|
);
|
|
}
|
|
|
|
// 3. 将数据复制到缓冲区
|
|
void* mapped_data = vertex_buffer_point->map();
|
|
if (mapped_data) {
|
|
memcpy(mapped_data, vertices.data(), buffer_size);
|
|
vertex_buffer_point->unmap();
|
|
}
|
|
else {
|
|
LOGE("Failed to map point vertex buffer for update.");
|
|
}
|
|
}
|
|
|
|
int point_index = 0;
|
|
void add_point(float* src, float* dest, int index)
|
|
{
|
|
dest[point_index * 3] = src[index * 3];
|
|
dest[point_index * 3 + 1] = src[index * 3 + 1];
|
|
dest[point_index * 3 + 2] = src[index * 3 + 2];
|
|
point_index++;
|
|
}
|
|
void TextureLoading::demo1(float* pos)
|
|
{
|
|
point_index = 0;
|
|
//std::vector<int> pointIndex= { 233,232,231,230,229,118,36,49,209,217,188,233};
|
|
std::vector<int> pointIndex = { 389,368,383,353,342,467,263,466,388,387,386,385,384,398,463,464,465,351,6,122,245,244,243,173,157,158,159,160,161,246,33,247,113,124,156,139,162,21,54,103,67,109,10,338,297,332,284,251,389 };
|
|
float points[100 * 3];
|
|
for (int i = 0; i < pointIndex.size(); ++i)
|
|
{
|
|
add_point(pos, points, pointIndex[i]);
|
|
}
|
|
std::vector<LineVertex> vertices;
|
|
update_point_vertex_buffer_line(points, point_index, 0.9f, 0.9f, 0.9f, vertices);
|
|
|
|
point_index = 0;
|
|
add_point(pos, points, 9);
|
|
add_point(pos, points, 168);
|
|
update_point_vertex_buffer_line(points, point_index, 1, 0, 0, vertices);
|
|
|
|
point_index = 0;
|
|
add_point(pos, points, 9);
|
|
add_point(pos, points, 104);
|
|
update_point_vertex_buffer_line(points, point_index, 1, 0, 0, vertices);
|
|
|
|
point_index = 0;
|
|
add_point(pos, points, 9);
|
|
add_point(pos, points, 108);
|
|
update_point_vertex_buffer_line(points, point_index, 1, 0, 0, vertices);
|
|
|
|
point_index = 0;
|
|
add_point(pos, points, 9);
|
|
add_point(pos, points, 337);
|
|
update_point_vertex_buffer_line(points, point_index, 1, 0, 0, vertices);
|
|
|
|
point_index = 0;
|
|
add_point(pos, points, 9);
|
|
add_point(pos, points, 333);
|
|
update_point_vertex_buffer_line(points, point_index, 1, 0, 0, vertices);
|
|
|
|
update_point_vertex_buffer_line_save(vertices);
|
|
}
|
|
|
|
|
|
void TextureLoading::update_point_vertex_buffer_line(float* pos, int count, float r, float g, float b, std::vector<LineVertex>& vertices)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mtx_point_line);
|
|
if (count <= 0) {
|
|
point_count_line = 0;
|
|
return; // 没有点数据，无需更新
|
|
}
|
|
|
|
|
|
glm::vec3 color = { r,g,b };
|
|
|
|
|
|
for (int i = 0; i < count - 1; ++i)
|
|
{
|
|
|
|
const glm::vec3& start = {pos[i*3], pos[i * 3+1], pos[i * 3+2] };
|
|
const glm::vec3& end = { pos[(i+1) * 3], pos[(i + 1) * 3 + 1], pos[(i + 1) * 3 + 2] };
|
|
|
|
// 线段起点顶点
|
|
vertices.push_back({
|
|
start, // position
|
|
color, // color
|
|
start, // lineStart
|
|
end, // lineEnd
|
|
});
|
|
|
|
// 线段终点顶点
|
|
vertices.push_back({
|
|
end, // position
|
|
color, // color
|
|
start, // lineStart (相同)
|
|
end, // lineEnd (相同)
|
|
});
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void TextureLoading::update_point_vertex_buffer_line_save(std::vector<LineVertex>& vertices)
|
|
{
|
|
point_count_line = vertices.size();
|
|
|
|
// 2. 更新或创建顶点缓冲区
|
|
VkDeviceSize buffer_size = sizeof(LineVertex) * point_count_line;
|
|
|
|
if (!vertex_buffer_point_line || vertex_buffer_point_line->get_size() < buffer_size) {
|
|
// 如果缓冲区不存在或太小，则重新创建
|
|
vertex_buffer_point_line.reset();
|
|
vertex_buffer_point_line = std::make_unique<vkb::core::BufferC>(get_device(),
|
|
buffer_size,
|
|
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
|
|
VMA_MEMORY_USAGE_CPU_TO_GPU // CPU 可写，GPU 可读
|
|
);
|
|
}
|
|
|
|
// 3. 将数据复制到缓冲区
|
|
void* mapped_data = vertex_buffer_point_line->map();
|
|
if (mapped_data) {
|
|
memcpy(mapped_data, vertices.data(), buffer_size);
|
|
vertex_buffer_point_line->unmap();
|
|
}
|
|
else {
|
|
LOGE("Failed to map point vertex buffer for update.");
|
|
}
|
|
}
|
|
|
|
void TextureLoading::draw_point_cloud(VkCommandBuffer command_buffer)
|
|
{
|
|
if (point_count == 0 || !vertex_buffer_point) {
|
|
return; // 没有点或缓冲区未准备好
|
|
}
|
|
|
|
vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.point);
|
|
vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout_point, 0, 1, &descriptor_set_point, 0, nullptr);
|
|
|
|
VkDeviceSize offsets[] = { 0 };
|
|
vkCmdBindVertexBuffers(command_buffer, 0, 1, vertex_buffer_point->get(), offsets);
|
|
|
|
vkCmdPushConstants(command_buffer, pipeline_layout_bg, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(float), &myFloatValue);
|
|
vkCmdDraw(command_buffer, point_count, 1, 0, 0); // 绘制 point_count 个顶点
|
|
}
|
|
|
|
void TextureLoading::draw_point_cloud_line(VkCommandBuffer command_buffer)
|
|
{
|
|
if (point_count_line == 0 || !vertex_buffer_point_line) {
|
|
return; // 没有点或缓冲区未准备好
|
|
}
|
|
|
|
vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.line);
|
|
vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout_point_line, 0, 1, &descriptor_set_point_line, 0, nullptr);
|
|
|
|
VkDeviceSize offsets[] = { 0 };
|
|
vkCmdBindVertexBuffers(command_buffer, 0, 1, vertex_buffer_point_line->get(), offsets);
|
|
|
|
vkCmdDraw(command_buffer, point_count_line, 1, 0, 0); // 绘制 point_count 个顶点
|
|
}
|
|
|