使用的外部库有FBX SDK、VulkanSDK 1.3.275.0、GLFW、glm
cpp
#define GLFW_INCLUDE_VULKAN
#include"targetver.h"
#include"FbxView.h"
#include<Windows.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <array>
#include <chrono>
#include <unordered_map>
#include <optional>
#include <set>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/quaternion.hpp>
#include <fbxsdk.h>
#include <algorithm> // std::clamp
#include <optional>
#pragma comment(lib,"vulkan-1.lib")
#pragma comment(lib,"glfw.lib")
#pragma comment(lib, "libfbxsdk-md.lib")
#pragma comment(lib, "libxml2-md.lib")
#pragma comment(lib, "zlib-md.lib")
#define PATH_MAX 255
std::string work_path;
std::string GetCurrentExeDirectory() {
char buffer[PATH_MAX * 2 + 1] = { 0 };
int n = -1;
#if defined(_WIN32)
n = GetModuleFileNameA(NULL, buffer, sizeof(buffer));
#elif defined(__MACH__) || defined(__APPLE__)
n = sizeof(buffer);
if (uv_exepath(buffer, &n) != 0) {
n = -1;
}
#elif defined(__linux__)
n = readlink("/proc/self/exe", buffer, sizeof(buffer));
#endif
std::string filePath;
if (n <= 0) {
filePath = "./";
}
else {
filePath = buffer;
}
#if defined(_WIN32)
int pos = 0;
int pos1 = 0;
for (auto& ch : filePath) {
if (ch == '\\') {
ch = '/';
pos1 = pos+1;
}
pos++;
}
filePath = filePath.substr(0, pos1);
#endif //defined(_WIN32)
return filePath;
}
void msg(std::wstring txt)
{
MessageBox(0, txt.c_str(), L"提示", 0);
}
// 窗口尺寸
const uint32_t WIDTH = 1280;
const uint32_t HEIGHT = 720;
// 顶点结构
struct Vertex {
glm::vec3 pos;
glm::vec3 normal;
glm::vec2 uv;
static VkVertexInputBindingDescription getBindingDescription() {
VkVertexInputBindingDescription bindingDesc{};
bindingDesc.binding = 0;
bindingDesc.stride = sizeof(Vertex);
bindingDesc.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
return bindingDesc;
}
static std::array<VkVertexInputAttributeDescription, 3> getAttributeDescriptions() {
std::array<VkVertexInputAttributeDescription, 3> attrs{};
attrs[0].binding = 0;
attrs[0].location = 0;
attrs[0].format = VK_FORMAT_R32G32B32_SFLOAT;
attrs[0].offset = offsetof(Vertex, pos);
attrs[1].binding = 0;
attrs[1].location = 1;
attrs[1].format = VK_FORMAT_R32G32B32_SFLOAT;
attrs[1].offset = offsetof(Vertex, normal);
attrs[2].binding = 0;
attrs[2].location = 2;
attrs[2].format = VK_FORMAT_R32G32_SFLOAT;
attrs[2].offset = offsetof(Vertex, uv);
return attrs;
}
};
// Uniform 缓冲对象
struct UniformBufferObject {
glm::mat4 model;
glm::mat4 view;
glm::mat4 proj;
glm::vec3 lightDir;
float padding; // 16字节对齐
};
// 全局摄像机控制变量（替换原来的 yaw/pitch/mousePressed）
static float camYaw = 0.0f; // 初始偏航角
static float camPitch = 0.3805f; // 初始俯仰角，对应位置(0,2,5)
static float camRadius = 5.385f; // 初始距离 sqrt(29)
static bool super_sc = false;
static bool super_sc1 = false;
static glm::vec3 camTarget(0.0f, 0.0f, 0.0f); // 观察目标点
static bool leftMousePressed = false; // 左键按下
static bool rightMousePressed = false; // 右键按下
static double lastX = 0.0, lastY = 0.0; // 上一次鼠标位置（用于当前按下的键）
// 封装 Vulkan 对象
class VulkanRenderer {
public:
uint32_t m_currentFrame = 0;
VulkanRenderer() = default;
~VulkanRenderer() { cleanup(); }
void init(GLFWwindow* window) {
m_window = window;
createInstance();
setupDebugMessenger();
createSurface();
pickPhysicalDevice();
createLogicalDevice();
createSwapChain();
createImageViews();
createRenderPass();
createDescriptorSetLayout();
createGraphicsPipeline();
createCommandPool();
createDepthResources();
createFramebuffers();
createUniformBuffers();
createDescriptorPool();
createDescriptorSets();
createCommandBuffers();
createSyncObjects();
}
void loadModel(const std::vector<Vertex>& vertices, const std::vector<uint32_t>& indices) {
m_vertices = vertices;
m_indices = indices;
createVertexBuffer();
createIndexBuffer();
}
void updateUniformBuffer(const UniformBufferObject& ubo, uint32_t currentFrame) {
void* data;
vkMapMemory(m_device, m_uniformBuffersMemory[currentFrame], 0, sizeof(ubo), 0, &data);
memcpy(data, &ubo, sizeof(ubo));
vkUnmapMemory(m_device, m_uniformBuffersMemory[currentFrame]);
}
void drawFrame() {
vkWaitForFences(m_device, 1, &m_inFlightFences[m_currentFrame], VK_TRUE, UINT64_MAX);
uint32_t imageIndex;
VkResult result = vkAcquireNextImageKHR(m_device, m_swapChain, UINT64_MAX,
m_imageAvailableSemaphores[m_currentFrame],
VK_NULL_HANDLE, &imageIndex);
if (result == VK_ERROR_OUT_OF_DATE_KHR) {
recreateSwapChain();
return;
}
else if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) {
throw std::runtime_error("failed to acquire swap chain image");
}
vkResetFences(m_device, 1, &m_inFlightFences[m_currentFrame]);
vkResetCommandBuffer(m_commandBuffers[m_currentFrame], 0);
recordCommandBuffer(m_commandBuffers[m_currentFrame], imageIndex);
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
VkSemaphore waitSemaphores[] = { m_imageAvailableSemaphores[m_currentFrame] };
VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = waitSemaphores;
submitInfo.pWaitDstStageMask = waitStages;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &m_commandBuffers[m_currentFrame];
VkSemaphore signalSemaphores[] = { m_renderFinishedSemaphores[m_currentFrame] };
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = signalSemaphores;
if (vkQueueSubmit(m_graphicsQueue, 1, &submitInfo, m_inFlightFences[m_currentFrame]) != VK_SUCCESS) {
throw std::runtime_error("failed to submit draw command buffer");
}
VkPresentInfoKHR presentInfo{};
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
presentInfo.waitSemaphoreCount = 1;
presentInfo.pWaitSemaphores = signalSemaphores;
VkSwapchainKHR swapChains[] = { m_swapChain };
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = swapChains;
presentInfo.pImageIndices = &imageIndex;
result = vkQueuePresentKHR(m_presentQueue, &presentInfo);
if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR) {
recreateSwapChain();
}
else if (result != VK_SUCCESS) {
throw std::runtime_error("failed to present swap chain image");
}
m_currentFrame = (m_currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
}
void waitIdle() {
vkDeviceWaitIdle(m_device);
}
private:
// ---------- Vulkan 成员变量 ----------
GLFWwindow* m_window = nullptr;
VkInstance m_instance = VK_NULL_HANDLE;
VkDebugUtilsMessengerEXT m_debugMessenger = VK_NULL_HANDLE;
VkSurfaceKHR m_surface = VK_NULL_HANDLE;
VkPhysicalDevice m_physicalDevice = VK_NULL_HANDLE;
VkDevice m_device = VK_NULL_HANDLE;
VkQueue m_graphicsQueue = VK_NULL_HANDLE;
VkQueue m_presentQueue = VK_NULL_HANDLE;
VkSwapchainKHR m_swapChain = VK_NULL_HANDLE;
std::vector<VkImage> m_swapChainImages;
VkFormat m_swapChainImageFormat;
VkExtent2D m_swapChainExtent;
std::vector<VkImageView> m_swapChainImageViews;
std::vector<VkFramebuffer> m_swapChainFramebuffers;
VkRenderPass m_renderPass = VK_NULL_HANDLE;
VkDescriptorSetLayout m_descriptorSetLayout = VK_NULL_HANDLE;
VkPipelineLayout m_pipelineLayout = VK_NULL_HANDLE;
VkPipeline m_graphicsPipeline = VK_NULL_HANDLE;
VkCommandPool m_commandPool = VK_NULL_HANDLE;
// 深度资源
VkImage m_depthImage = VK_NULL_HANDLE;
VkDeviceMemory m_depthImageMemory = VK_NULL_HANDLE;
VkImageView m_depthImageView = VK_NULL_HANDLE;
// 顶点/索引缓冲
VkBuffer m_vertexBuffer = VK_NULL_HANDLE;
VkDeviceMemory m_vertexBufferMemory = VK_NULL_HANDLE;
VkBuffer m_indexBuffer = VK_NULL_HANDLE;
VkDeviceMemory m_indexBufferMemory = VK_NULL_HANDLE;
// Uniform 缓冲
static constexpr int MAX_FRAMES_IN_FLIGHT = 2;
std::vector<VkBuffer> m_uniformBuffers;
std::vector<VkDeviceMemory> m_uniformBuffersMemory;
std::vector<void*> m_uniformBuffersMapped;
VkDescriptorPool m_descriptorPool = VK_NULL_HANDLE;
std::vector<VkDescriptorSet> m_descriptorSets;
// 同步对象
std::vector<VkSemaphore> m_imageAvailableSemaphores;
std::vector<VkSemaphore> m_renderFinishedSemaphores;
std::vector<VkFence> m_inFlightFences;
std::vector<VkCommandBuffer> m_commandBuffers;
// 模型数据
std::vector<Vertex> m_vertices;
std::vector<uint32_t> m_indices;
// ---------- 辅助函数 ----------
void createInstance() {
// 启用验证层（可选）
VkApplicationInfo appInfo{};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = "FBX Viewer";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "No Engine";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_1;
VkInstanceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pApplicationInfo = &appInfo;
// 需要的扩展
uint32_t glfwExtensionCount = 0;
const char** glfwExtensions;
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
createInfo.enabledExtensionCount = glfwExtensionCount;
createInfo.ppEnabledExtensionNames = glfwExtensions;
createInfo.enabledLayerCount = 0; // 暂不启用验证层
if (vkCreateInstance(&createInfo, nullptr, &m_instance) != VK_SUCCESS) {
throw std::runtime_error("failed to create instance");
}
}
void setupDebugMessenger() {
// 略，可留空
}
void createSurface() {
if (glfwCreateWindowSurface(m_instance, m_window, nullptr, &m_surface) != VK_SUCCESS) {
throw std::runtime_error("failed to create window surface");
}
}
void pickPhysicalDevice() {
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(m_instance, &deviceCount, nullptr);
if (deviceCount == 0) throw std::runtime_error("no Vulkan capable GPU");
std::vector<VkPhysicalDevice> devices(deviceCount);
vkEnumeratePhysicalDevices(m_instance, &deviceCount, devices.data());
for (const auto& device : devices) {
if (isDeviceSuitable(device)) {
m_physicalDevice = device;
break;
}
}
if (m_physicalDevice == VK_NULL_HANDLE) throw std::runtime_error("no suitable GPU");
}
bool isDeviceSuitable(VkPhysicalDevice device) {
QueueFamilyIndices indices = findQueueFamilies(device);
bool extensionsSupported = checkDeviceExtensionSupport(device);
bool swapChainAdequate = false;
if (extensionsSupported) {
SwapChainSupportDetails details = querySwapChainSupport(device);
swapChainAdequate = !details.formats.empty() && !details.presentModes.empty();
}
return indices.isComplete() && extensionsSupported && swapChainAdequate;
}
struct QueueFamilyIndices {
std::optional<uint32_t> graphicsFamily;
std::optional<uint32_t> presentFamily;
bool isComplete() { return graphicsFamily.has_value() && presentFamily.has_value(); }
};
QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device) {
QueueFamilyIndices indices;
uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());
for (uint32_t i = 0; i < queueFamilyCount; i++) {
if (queueFamilies[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
indices.graphicsFamily = i;
}
VkBool32 presentSupport = false;
vkGetPhysicalDeviceSurfaceSupportKHR(device, i, m_surface, &presentSupport);
if (presentSupport) indices.presentFamily = i;
if (indices.isComplete()) break;
}
return indices;
}
bool checkDeviceExtensionSupport(VkPhysicalDevice device) {
std::vector<const char*> requiredExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
uint32_t extensionCount;
vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);
std::vector<VkExtensionProperties> availableExtensions(extensionCount);
vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, availableExtensions.data());
std::set<std::string> requiredSet(requiredExtensions.begin(), requiredExtensions.end());
for (const auto& ext : availableExtensions) requiredSet.erase(ext.extensionName);
return requiredSet.empty();
}
struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities;
std::vector<VkSurfaceFormatKHR> formats;
std::vector<VkPresentModeKHR> presentModes;
};
SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device) {
SwapChainSupportDetails details;
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, m_surface, &details.capabilities);
uint32_t formatCount;
vkGetPhysicalDeviceSurfaceFormatsKHR(device, m_surface, &formatCount, nullptr);
if (formatCount != 0) {
details.formats.resize(formatCount);
vkGetPhysicalDeviceSurfaceFormatsKHR(device, m_surface, &formatCount, details.formats.data());
}
uint32_t presentModeCount;
vkGetPhysicalDeviceSurfacePresentModesKHR(device, m_surface, &presentModeCount, nullptr);
if (presentModeCount != 0) {
details.presentModes.resize(presentModeCount);
vkGetPhysicalDeviceSurfacePresentModesKHR(device, m_surface, &presentModeCount, details.presentModes.data());
}
return details;
}
void createLogicalDevice() {
QueueFamilyIndices indices = findQueueFamilies(m_physicalDevice);
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
std::set<uint32_t> uniqueQueueFamilies = { indices.graphicsFamily.value(), indices.presentFamily.value() };
float queuePriority = 1.0f;
for (uint32_t queueFamily : uniqueQueueFamilies) {
VkDeviceQueueCreateInfo queueCreateInfo{};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = queueFamily;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = &queuePriority;
queueCreateInfos.push_back(queueCreateInfo);
}
VkPhysicalDeviceFeatures deviceFeatures{};
deviceFeatures.samplerAnisotropy = VK_TRUE; // 如果需要
VkDeviceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
createInfo.pQueueCreateInfos = queueCreateInfos.data();
createInfo.pEnabledFeatures = &deviceFeatures;
std::vector<const char*> extensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
createInfo.enabledExtensionCount = extensions.size();
createInfo.ppEnabledExtensionNames = extensions.data();
createInfo.enabledLayerCount = 0;
if (vkCreateDevice(m_physicalDevice, &createInfo, nullptr, &m_device) != VK_SUCCESS) {
throw std::runtime_error("failed to create logical device");
}
vkGetDeviceQueue(m_device, indices.graphicsFamily.value(), 0, &m_graphicsQueue);
vkGetDeviceQueue(m_device, indices.presentFamily.value(), 0, &m_presentQueue);
}
void createSwapChain() {
SwapChainSupportDetails details = querySwapChainSupport(m_physicalDevice);
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(details.formats);
VkPresentModeKHR presentMode = chooseSwapPresentMode(details.presentModes);
VkExtent2D extent = chooseSwapExtent(details.capabilities);
uint32_t imageCount = details.capabilities.minImageCount + 1;
if (details.capabilities.maxImageCount > 0 && imageCount > details.capabilities.maxImageCount)
imageCount = details.capabilities.maxImageCount;
VkSwapchainCreateInfoKHR createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = m_surface;
createInfo.minImageCount = imageCount;
createInfo.imageFormat = surfaceFormat.format;
createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
QueueFamilyIndices indices = findQueueFamilies(m_physicalDevice);
uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() };
if (indices.graphicsFamily != indices.presentFamily) {
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
createInfo.queueFamilyIndexCount = 2;
createInfo.pQueueFamilyIndices = queueFamilyIndices;
}
else {
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
}
createInfo.preTransform = details.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
createInfo.oldSwapchain = VK_NULL_HANDLE;
if (vkCreateSwapchainKHR(m_device, &createInfo, nullptr, &m_swapChain) != VK_SUCCESS) {
throw std::runtime_error("failed to create swap chain");
}
vkGetSwapchainImagesKHR(m_device, m_swapChain, &imageCount, nullptr);
m_swapChainImages.resize(imageCount);
vkGetSwapchainImagesKHR(m_device, m_swapChain, &imageCount, m_swapChainImages.data());
m_swapChainImageFormat = surfaceFormat.format;
m_swapChainExtent = extent;
}
VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats) {
for (const auto& fmt : availableFormats) {
if (fmt.format == VK_FORMAT_B8G8R8A8_SRGB && fmt.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
return fmt;
}
return availableFormats[0];
}
VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availableModes) {
for (auto mode : availableModes) {
if (mode == VK_PRESENT_MODE_MAILBOX_KHR) return mode;
}
return VK_PRESENT_MODE_FIFO_KHR;
}
VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities) {
if (capabilities.currentExtent.width != UINT32_MAX) {
return capabilities.currentExtent;
}
else {
int width, height;
glfwGetFramebufferSize(m_window, &width, &height);
VkExtent2D actualExtent = { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
actualExtent.width = std::clamp(actualExtent.width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
actualExtent.height = std::clamp(actualExtent.height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height);
return actualExtent;
}
}
void createImageViews() {
m_swapChainImageViews.resize(m_swapChainImages.size());
for (size_t i = 0; i < m_swapChainImages.size(); i++) {
VkImageViewCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
createInfo.image = m_swapChainImages[i];
createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
createInfo.format = m_swapChainImageFormat;
createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
createInfo.subresourceRange.baseMipLevel = 0;
createInfo.subresourceRange.levelCount = 1;
createInfo.subresourceRange.baseArrayLayer = 0;
createInfo.subresourceRange.layerCount = 1;
if (vkCreateImageView(m_device, &createInfo, nullptr, &m_swapChainImageViews[i]) != VK_SUCCESS) {
throw std::runtime_error("failed to create image views");
}
}
}
void createRenderPass() {
VkAttachmentDescription colorAttachment{};
colorAttachment.format = m_swapChainImageFormat;
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
VkAttachmentDescription depthAttachment{};
depthAttachment.format = findDepthFormat();
depthAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
depthAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
depthAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
depthAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
depthAttachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
VkAttachmentReference colorAttachmentRef{};
colorAttachmentRef.attachment = 0;
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkAttachmentReference depthAttachmentRef{};
depthAttachmentRef.attachment = 1;
depthAttachmentRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass{};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &colorAttachmentRef;
subpass.pDepthStencilAttachment = &depthAttachmentRef;
VkSubpassDependency dependency{};
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
dependency.dstSubpass = 0;
dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
dependency.srcAccessMask = 0;
dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
std::array<VkAttachmentDescription, 2> attachments = { colorAttachment, depthAttachment };
VkRenderPassCreateInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
renderPassInfo.pAttachments = attachments.data();
renderPassInfo.subpassCount = 1;
renderPassInfo.pSubpasses = &subpass;
renderPassInfo.dependencyCount = 1;
renderPassInfo.pDependencies = &dependency;
if (vkCreateRenderPass(m_device, &renderPassInfo, nullptr, &m_renderPass) != VK_SUCCESS) {
throw std::runtime_error("failed to create render pass");
}
}
void createDescriptorSetLayout() {
VkDescriptorSetLayoutBinding uboLayoutBinding{};
uboLayoutBinding.binding = 0;
uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
uboLayoutBinding.descriptorCount = 1;
uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
uboLayoutBinding.pImmutableSamplers = nullptr;
VkDescriptorSetLayoutCreateInfo layoutInfo{};
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layoutInfo.bindingCount = 1;
layoutInfo.pBindings = &uboLayoutBinding;
if (vkCreateDescriptorSetLayout(m_device, &layoutInfo, nullptr, &m_descriptorSetLayout) != VK_SUCCESS) {
throw std::runtime_error("failed to create descriptor set layout");
}
}
void createGraphicsPipeline() {
auto vertShaderCode = readFile(work_path+"shader.vert");
auto fragShaderCode = readFile(work_path + "shader.frag");
VkShaderModule vertModule = createShaderModule(vertShaderCode);
VkShaderModule fragModule = createShaderModule(fragShaderCode);
VkPipelineShaderStageCreateInfo vertStageInfo{};
vertStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
vertStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
vertStageInfo.module = vertModule;
vertStageInfo.pName = "main";
VkPipelineShaderStageCreateInfo fragStageInfo{};
fragStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
fragStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
fragStageInfo.module = fragModule;
fragStageInfo.pName = "main";
VkPipelineShaderStageCreateInfo shaderStages[] = { vertStageInfo, fragStageInfo };
auto bindingDesc = Vertex::getBindingDescription();
auto attrDescs = Vertex::getAttributeDescriptions();
VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
vertexInputInfo.vertexBindingDescriptionCount = 1;
vertexInputInfo.pVertexBindingDescriptions = &bindingDesc;
vertexInputInfo.vertexAttributeDescriptionCount = static_cast<uint32_t>(attrDescs.size());
vertexInputInfo.pVertexAttributeDescriptions = attrDescs.data();
VkPipelineInputAssemblyStateCreateInfo inputAssembly{};
inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
inputAssembly.primitiveRestartEnable = VK_FALSE;
VkViewport viewport{};
viewport.x = 0.0f;
viewport.y = 0.0f;
viewport.width = (float)m_swapChainExtent.width;
viewport.height = (float)m_swapChainExtent.height;
viewport.minDepth = 0.0f;
viewport.maxDepth = 1.0f;
VkRect2D scissor{};
scissor.offset = { 0, 0 };
scissor.extent = m_swapChainExtent;
VkPipelineViewportStateCreateInfo viewportState{};
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
viewportState.viewportCount = 1;
viewportState.pViewports = &viewport;
viewportState.scissorCount = 1;
viewportState.pScissors = &scissor;
VkPipelineRasterizationStateCreateInfo rasterizer{};
rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
rasterizer.depthClampEnable = VK_FALSE;
rasterizer.rasterizerDiscardEnable = VK_FALSE;
rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
rasterizer.lineWidth = 1.0f;
rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
rasterizer.depthBiasEnable = VK_FALSE;
VkPipelineMultisampleStateCreateInfo multisampling{};
multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
multisampling.sampleShadingEnable = VK_FALSE;
multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
VkPipelineDepthStencilStateCreateInfo depthStencil{};
depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
depthStencil.depthTestEnable = VK_TRUE;
depthStencil.depthWriteEnable = VK_TRUE;
depthStencil.depthCompareOp = VK_COMPARE_OP_LESS;
depthStencil.depthBoundsTestEnable = VK_FALSE;
depthStencil.stencilTestEnable = VK_FALSE;
VkPipelineColorBlendAttachmentState colorBlendAttachment{};
colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
colorBlendAttachment.blendEnable = VK_FALSE;
VkPipelineColorBlendStateCreateInfo colorBlending{};
colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
colorBlending.logicOpEnable = VK_FALSE;
colorBlending.logicOp = VK_LOGIC_OP_COPY;
colorBlending.attachmentCount = 1;
colorBlending.pAttachments = &colorBlendAttachment;
colorBlending.blendConstants[0] = 0.0f;
colorBlending.blendConstants[1] = 0.0f;
colorBlending.blendConstants[2] = 0.0f;
colorBlending.blendConstants[3] = 0.0f;
VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pipelineLayoutInfo.setLayoutCount = 1;
pipelineLayoutInfo.pSetLayouts = &m_descriptorSetLayout;
if (vkCreatePipelineLayout(m_device, &pipelineLayoutInfo, nullptr, &m_pipelineLayout) != VK_SUCCESS) {
throw std::runtime_error("failed to create pipeline layout");
}
VkGraphicsPipelineCreateInfo pipelineInfo{};
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
pipelineInfo.stageCount = 2;
pipelineInfo.pStages = shaderStages;
pipelineInfo.pVertexInputState = &vertexInputInfo;
pipelineInfo.pInputAssemblyState = &inputAssembly;
pipelineInfo.pViewportState = &viewportState;
pipelineInfo.pRasterizationState = &rasterizer;
pipelineInfo.pMultisampleState = &multisampling;
pipelineInfo.pDepthStencilState = &depthStencil;
pipelineInfo.pColorBlendState = &colorBlending;
pipelineInfo.layout = m_pipelineLayout;
pipelineInfo.renderPass = m_renderPass;
pipelineInfo.subpass = 0;
pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
if (vkCreateGraphicsPipelines(m_device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &m_graphicsPipeline) != VK_SUCCESS) {
throw std::runtime_error("failed to create graphics pipeline");
}
vkDestroyShaderModule(m_device, fragModule, nullptr);
vkDestroyShaderModule(m_device, vertModule, nullptr);
}
static std::vector<char> readFile(const std::string& filename) {
std::ifstream file(filename, std::ios::ate | std::ios::binary);
if (!file.is_open()) throw std::runtime_error("failed to open file: " + filename);
size_t fileSize = (size_t)file.tellg();
std::vector<char> buffer(fileSize);
file.seekg(0);
file.read(buffer.data(), fileSize);
return buffer;
}
VkShaderModule createShaderModule(const std::vector<char>& code) {
VkShaderModuleCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
createInfo.codeSize = code.size();
createInfo.pCode = reinterpret_cast<const uint32_t*>(code.data());
VkShaderModule module;
if (vkCreateShaderModule(m_device, &createInfo, nullptr, &module) != VK_SUCCESS) {
throw std::runtime_error("failed to create shader module");
}
return module;
}
void createFramebuffers() {
m_swapChainFramebuffers.resize(m_swapChainImageViews.size());
for (size_t i = 0; i < m_swapChainImageViews.size(); i++) {
std::array<VkImageView, 2> attachments = { m_swapChainImageViews[i], m_depthImageView };
VkFramebufferCreateInfo framebufferInfo{};
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
framebufferInfo.renderPass = m_renderPass;
framebufferInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
framebufferInfo.pAttachments = attachments.data();
framebufferInfo.width = m_swapChainExtent.width;
framebufferInfo.height = m_swapChainExtent.height;
framebufferInfo.layers = 1;
if (vkCreateFramebuffer(m_device, &framebufferInfo, nullptr, &m_swapChainFramebuffers[i]) != VK_SUCCESS) {
throw std::runtime_error("failed to create framebuffer");
}
}
}
void createCommandPool() {
QueueFamilyIndices indices = findQueueFamilies(m_physicalDevice);
VkCommandPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
poolInfo.queueFamilyIndex = indices.graphicsFamily.value();
if (vkCreateCommandPool(m_device, &poolInfo, nullptr, &m_commandPool) != VK_SUCCESS) {
throw std::runtime_error("failed to create command pool");
}
}
void createDepthResources() {
VkFormat depthFormat = findDepthFormat();
createImage(m_swapChainExtent.width, m_swapChainExtent.height, depthFormat,
VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, m_depthImage, m_depthImageMemory);
m_depthImageView = createImageView(m_depthImage, depthFormat, VK_IMAGE_ASPECT_DEPTH_BIT);
}
VkFormat findDepthFormat() {
return findSupportedFormat({ VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT },
VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
}
VkFormat findSupportedFormat(const std::vector<VkFormat>& candidates, VkImageTiling tiling, VkFormatFeatureFlags features) {
for (VkFormat fmt : candidates) {
VkFormatProperties props;
vkGetPhysicalDeviceFormatProperties(m_physicalDevice, fmt, &props);
if (tiling == VK_IMAGE_TILING_LINEAR && (props.linearTilingFeatures & features) == features) return fmt;
if (tiling == VK_IMAGE_TILING_OPTIMAL && (props.optimalTilingFeatures & features) == features) return fmt;
}
throw std::runtime_error("failed to find supported format");
}
void createImage(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling,
VkImageUsageFlags usage, VkMemoryPropertyFlags properties,
VkImage& image, VkDeviceMemory& imageMemory) {
VkImageCreateInfo imageInfo{};
imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageInfo.imageType = VK_IMAGE_TYPE_2D;
imageInfo.extent.width = width;
imageInfo.extent.height = height;
imageInfo.extent.depth = 1;
imageInfo.mipLevels = 1;
imageInfo.arrayLayers = 1;
imageInfo.format = format;
imageInfo.tiling = tiling;
imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageInfo.usage = usage;
imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
if (vkCreateImage(m_device, &imageInfo, nullptr, &image) != VK_SUCCESS) {
throw std::runtime_error("failed to create image");
}
VkMemoryRequirements memRequirements;
vkGetImageMemoryRequirements(m_device, image, &memRequirements);
VkMemoryAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties);
if (vkAllocateMemory(m_device, &allocInfo, nullptr, &imageMemory) != VK_SUCCESS) {
throw std::runtime_error("failed to allocate image memory");
}
vkBindImageMemory(m_device, image, imageMemory, 0);
}
VkImageView createImageView(VkImage image, VkFormat format, VkImageAspectFlags aspectFlags) {
VkImageViewCreateInfo viewInfo{};
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
viewInfo.image = image;
viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
viewInfo.format = format;
viewInfo.subresourceRange.aspectMask = aspectFlags;
viewInfo.subresourceRange.baseMipLevel = 0;
viewInfo.subresourceRange.levelCount = 1;
viewInfo.subresourceRange.baseArrayLayer = 0;
viewInfo.subresourceRange.layerCount = 1;
VkImageView imageView;
if (vkCreateImageView(m_device, &viewInfo, nullptr, &imageView) != VK_SUCCESS) {
throw std::runtime_error("failed to create image view");
}
return imageView;
}
uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) {
VkPhysicalDeviceMemoryProperties memProperties;
vkGetPhysicalDeviceMemoryProperties(m_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");
}
void createVertexBuffer() {
VkDeviceSize bufferSize = sizeof(m_vertices[0]) * m_vertices.size();
VkBuffer stagingBuffer;
VkDeviceMemory stagingBufferMemory;
createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
stagingBuffer, stagingBufferMemory);
void* data;
vkMapMemory(m_device, stagingBufferMemory, 0, bufferSize, 0, &data);
memcpy(data, m_vertices.data(), (size_t)bufferSize);
vkUnmapMemory(m_device, stagingBufferMemory);
createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, m_vertexBuffer, m_vertexBufferMemory);
copyBuffer(stagingBuffer, m_vertexBuffer, bufferSize);
vkDestroyBuffer(m_device, stagingBuffer, nullptr);
vkFreeMemory(m_device, stagingBufferMemory, nullptr);
}
void createIndexBuffer() {
VkDeviceSize bufferSize = sizeof(m_indices[0]) * m_indices.size();
VkBuffer stagingBuffer;
VkDeviceMemory stagingBufferMemory;
createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
stagingBuffer, stagingBufferMemory);
void* data;
vkMapMemory(m_device, stagingBufferMemory, 0, bufferSize, 0, &data);
memcpy(data, m_indices.data(), (size_t)bufferSize);
vkUnmapMemory(m_device, stagingBufferMemory);
createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, m_indexBuffer, m_indexBufferMemory);
copyBuffer(stagingBuffer, m_indexBuffer, bufferSize);
vkDestroyBuffer(m_device, stagingBuffer, nullptr);
vkFreeMemory(m_device, stagingBufferMemory, nullptr);
}
void createBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties,
VkBuffer& buffer, VkDeviceMemory& bufferMemory) {
VkBufferCreateInfo bufferInfo{};
bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bufferInfo.size = size;
bufferInfo.usage = usage;
bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
if (vkCreateBuffer(m_device, &bufferInfo, nullptr, &buffer) != VK_SUCCESS) {
throw std::runtime_error("failed to create buffer");
}
VkMemoryRequirements memRequirements;
vkGetBufferMemoryRequirements(m_device, buffer, &memRequirements);
VkMemoryAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties);
if (vkAllocateMemory(m_device, &allocInfo, nullptr, &bufferMemory) != VK_SUCCESS) {
throw std::runtime_error("failed to allocate buffer memory");
}
vkBindBufferMemory(m_device, buffer, bufferMemory, 0);
}
void copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size) {
VkCommandBufferAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandPool = m_commandPool;
allocInfo.commandBufferCount = 1;
VkCommandBuffer commandBuffer;
vkAllocateCommandBuffers(m_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);
VkBufferCopy copyRegion{};
copyRegion.size = size;
vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, ©Region);
vkEndCommandBuffer(commandBuffer);
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &commandBuffer;
vkQueueSubmit(m_graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE);
vkQueueWaitIdle(m_graphicsQueue);
vkFreeCommandBuffers(m_device, m_commandPool, 1, &commandBuffer);
}
void createUniformBuffers() {
VkDeviceSize bufferSize = sizeof(UniformBufferObject);
m_uniformBuffers.resize(MAX_FRAMES_IN_FLIGHT);
m_uniformBuffersMemory.resize(MAX_FRAMES_IN_FLIGHT);
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
createBuffer(bufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
m_uniformBuffers[i], m_uniformBuffersMemory[i]);
}
}
void createDescriptorPool() {
VkDescriptorPoolSize poolSize{};
poolSize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
poolSize.descriptorCount = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT);
VkDescriptorPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
poolInfo.poolSizeCount = 1;
poolInfo.pPoolSizes = &poolSize;
poolInfo.maxSets = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT);
if (vkCreateDescriptorPool(m_device, &poolInfo, nullptr, &m_descriptorPool) != VK_SUCCESS) {
throw std::runtime_error("failed to create descriptor pool");
}
}
void createDescriptorSets() {
std::vector<VkDescriptorSetLayout> layouts(MAX_FRAMES_IN_FLIGHT, m_descriptorSetLayout);
VkDescriptorSetAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
allocInfo.descriptorPool = m_descriptorPool;
allocInfo.descriptorSetCount = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT);
allocInfo.pSetLayouts = layouts.data();
m_descriptorSets.resize(MAX_FRAMES_IN_FLIGHT);
if (vkAllocateDescriptorSets(m_device, &allocInfo, m_descriptorSets.data()) != VK_SUCCESS) {
throw std::runtime_error("failed to allocate descriptor sets");
}
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
VkDescriptorBufferInfo bufferInfo{};
bufferInfo.buffer = m_uniformBuffers[i];
bufferInfo.offset = 0;
bufferInfo.range = sizeof(UniformBufferObject);
VkWriteDescriptorSet descriptorWrite{};
descriptorWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptorWrite.dstSet = m_descriptorSets[i];
descriptorWrite.dstBinding = 0;
descriptorWrite.dstArrayElement = 0;
descriptorWrite.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
descriptorWrite.descriptorCount = 1;
descriptorWrite.pBufferInfo = &bufferInfo;
vkUpdateDescriptorSets(m_device, 1, &descriptorWrite, 0, nullptr);
}
}
void createCommandBuffers() {
m_commandBuffers.resize(MAX_FRAMES_IN_FLIGHT);
VkCommandBufferAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.commandPool = m_commandPool;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandBufferCount = (uint32_t)m_commandBuffers.size();
if (vkAllocateCommandBuffers(m_device, &allocInfo, m_commandBuffers.data()) != VK_SUCCESS) {
throw std::runtime_error("failed to allocate command buffers");
}
}
void recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) {
VkCommandBufferBeginInfo beginInfo{};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
if (vkBeginCommandBuffer(commandBuffer, &beginInfo) != VK_SUCCESS) {
throw std::runtime_error("failed to begin recording command buffer");
}
VkRenderPassBeginInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
renderPassInfo.renderPass = m_renderPass;
renderPassInfo.framebuffer = m_swapChainFramebuffers[imageIndex];
renderPassInfo.renderArea.offset = { 0, 0 };
renderPassInfo.renderArea.extent = m_swapChainExtent;
std::array<VkClearValue, 2> clearValues{};
clearValues[0].color = { {0.0f, 0.0f, 0.0f, 1.0f} };
clearValues[1].depthStencil = { 1.0f, 0 };
renderPassInfo.clearValueCount = static_cast<uint32_t>(clearValues.size());
renderPassInfo.pClearValues = clearValues.data();
vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, m_graphicsPipeline);
VkBuffer vertexBuffers[] = { m_vertexBuffer };
VkDeviceSize offsets[] = { 0 };
vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);
vkCmdBindIndexBuffer(commandBuffer, m_indexBuffer, 0, VK_INDEX_TYPE_UINT32);
vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipelineLayout, 0, 1, &m_descriptorSets[m_currentFrame], 0, nullptr);
vkCmdDrawIndexed(commandBuffer, static_cast<uint32_t>(m_indices.size()), 1, 0, 0, 0);
vkCmdEndRenderPass(commandBuffer);
if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) {
throw std::runtime_error("failed to record command buffer");
}
}
void createSyncObjects() {
m_imageAvailableSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
m_renderFinishedSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
m_inFlightFences.resize(MAX_FRAMES_IN_FLIGHT);
VkSemaphoreCreateInfo semaphoreInfo{};
semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
VkFenceCreateInfo fenceInfo{};
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
if (vkCreateSemaphore(m_device, &semaphoreInfo, nullptr, &m_imageAvailableSemaphores[i]) != VK_SUCCESS ||
vkCreateSemaphore(m_device, &semaphoreInfo, nullptr, &m_renderFinishedSemaphores[i]) != VK_SUCCESS ||
vkCreateFence(m_device, &fenceInfo, nullptr, &m_inFlightFences[i]) != VK_SUCCESS) {
throw std::runtime_error("failed to create sync objects");
}
}
}
void recreateSwapChain() {
int width = 0, height = 0;
while (width == 0 || height == 0) {
glfwGetFramebufferSize(m_window, &width, &height);
glfwWaitEvents();
}
vkDeviceWaitIdle(m_device);
cleanupSwapChain();
createSwapChain();
createImageViews();
createRenderPass(); // 需要重新创建依赖深度/颜色格式的RenderPass
createGraphicsPipeline();
createDepthResources();
createFramebuffers();
}
void cleanupSwapChain() {
vkDestroyImageView(m_device, m_depthImageView, nullptr);
vkDestroyImage(m_device, m_depthImage, nullptr);
vkFreeMemory(m_device, m_depthImageMemory, nullptr);
for (auto fb : m_swapChainFramebuffers) vkDestroyFramebuffer(m_device, fb, nullptr);
vkFreeCommandBuffers(m_device, m_commandPool, static_cast<uint32_t>(m_commandBuffers.size()), m_commandBuffers.data());
vkDestroyPipeline(m_device, m_graphicsPipeline, nullptr);
vkDestroyPipelineLayout(m_device, m_pipelineLayout, nullptr);
vkDestroyRenderPass(m_device, m_renderPass, nullptr);
for (auto iv : m_swapChainImageViews) vkDestroyImageView(m_device, iv, nullptr);
vkDestroySwapchainKHR(m_device, m_swapChain, nullptr);
}
void cleanup() {
cleanupSwapChain();
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
vkDestroyBuffer(m_device, m_uniformBuffers[i], nullptr);
vkFreeMemory(m_device, m_uniformBuffersMemory[i], nullptr);
}
vkDestroyDescriptorPool(m_device, m_descriptorPool, nullptr);
vkDestroyDescriptorSetLayout(m_device, m_descriptorSetLayout, nullptr);
vkDestroyBuffer(m_device, m_indexBuffer, nullptr);
vkFreeMemory(m_device, m_indexBufferMemory, nullptr);
vkDestroyBuffer(m_device, m_vertexBuffer, nullptr);
vkFreeMemory(m_device, m_vertexBufferMemory, nullptr);
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
vkDestroySemaphore(m_device, m_renderFinishedSemaphores[i], nullptr);
vkDestroySemaphore(m_device, m_imageAvailableSemaphores[i], nullptr);
vkDestroyFence(m_device, m_inFlightFences[i], nullptr);
}
vkDestroyCommandPool(m_device, m_commandPool, nullptr);
vkDestroyDevice(m_device, nullptr);
vkDestroySurfaceKHR(m_instance, m_surface, nullptr);
vkDestroyInstance(m_instance, nullptr);
}
};
// ---------- FBX 加载器 ----------
class FBXLoader {
public:
bool LoadScene(const std::string& filename) {
FbxManager* sdkManager = FbxManager::Create();
FbxIOSettings* ios = FbxIOSettings::Create(sdkManager, IOSROOT);
sdkManager->SetIOSettings(ios);
FbxImporter* importer = FbxImporter::Create(sdkManager, "");
if (!importer->Initialize(filename.c_str(), -1, sdkManager->GetIOSettings())) {
msg(L"Failed to initialize FBX importer");
return false;
}
scene = FbxScene::Create(sdkManager, "Scene");
if (!importer->Import(scene)) {
msg(L"Failed to import FBX scene.");
return false;
}
importer->Destroy();
// 转换坐标系为右手系 Y-up (Vulkan 使用右手系，Y向上)
FbxAxisSystem::DirectX.ConvertScene(scene);
// 获取第一个动画栈
int animStackCount = scene->GetSrcObjectCount<FbxAnimStack>();
if (animStackCount > 0) {
//currentAnimStack = scene->GetSrcObject<FbxAnimStack>(0);
//std::cout << "Using animation stack: " << currentAnimStack->GetName() << std::endl;
//int layerCount = currentAnimStack->GetMemberCount<FbxAnimLayer>();
//if (layerCount > 0) {
// currentAnimLayer = currentAnimStack->GetMember<FbxAnimLayer>(0);
// //scene->GetCurrentAnimationStack()->SetCurrentAnimLayer(currentAnimLayer);
// if (currentAnimStack) {
// currentAnimStack->SetCurrentLayer(currentAnimLayer);
// }
//}
//// 获取时间范围
///*FbxTimeSpan timeSpan;
//currentAnimStack->GetLocalTimeSpan(timeSpan);
//duration = timeSpan.GetDuration();*/
//FbxTimeSpan timeSpan = currentAnimStack->GetLocalTimeSpan(); // 直接接收返回值
//duration = timeSpan.GetDuration();
currentAnimStack = scene->GetSrcObject<FbxAnimStack>(0);
// 将当前动画栈设置为场景的当前动画栈
scene->SetCurrentAnimationStack(currentAnimStack);
// 获取时间范围
FbxTimeSpan timeSpan = currentAnimStack->GetLocalTimeSpan(); // 无参函数，返回 FbxTimeSpan
duration = timeSpan.GetDuration();
}
// 提取网格数据（简化：只取第一个网格）
ExtractMesh(scene->GetRootNode());
return true;
}
void ExtractMesh(FbxNode* node) {
FbxNodeAttribute* attr = node->GetNodeAttribute();
if (attr && attr->GetAttributeType() == FbxNodeAttribute::eMesh) {
FbxMesh* mesh = (FbxMesh*)attr;
ReadMesh(mesh);
return; // 只取第一个网格
}
for (int i = 0; i < node->GetChildCount(); ++i) {
ExtractMesh(node->GetChild(i));
if (!vertices.empty()) return; // 找到网格后停止
}
}
void ReadMesh(FbxMesh* mesh) {
int polyCount = mesh->GetPolygonCount();
int vertexCount = 0;
for (int i = 0; i < polyCount; ++i) {
vertexCount += mesh->GetPolygonSize(i);
}
// 获取控制点
FbxVector4* controlPoints = mesh->GetControlPoints();
int cpCount = mesh->GetControlPointsCount();
// 获取法线
FbxGeometryElementNormal* normalElement = mesh->GetElementNormal(0);
bool hasNormal = (normalElement != nullptr);
// 获取 UV
FbxGeometryElementUV* uvElement = mesh->GetElementUV(0);
bool hasUV = (uvElement != nullptr);
// 遍历所有多边形，生成顶点列表
for (int polyIdx = 0; polyIdx < polyCount; ++polyIdx) {
int polySize = mesh->GetPolygonSize(polyIdx);
for (int vertInPoly = 0; vertInPoly < polySize; ++vertInPoly) {
int cpIdx = mesh->GetPolygonVertex(polyIdx, vertInPoly);
Vertex vertex;
// 位置
FbxVector4 pos = controlPoints[cpIdx];
vertex.pos = glm::vec3((float)pos[0], (float)pos[1], (float)pos[2]);
// 法线
if (hasNormal) {
/* FbxVector4 normal;
if (normalElement->GetMappingMode() == FbxGeometryElement::eByPolygonVertex) {
int normalIdx = mesh->GetPolygonVertexNormal(polyIdx, vertInPoly);
normal = normalElement->GetDirectArray().GetAt(normalIdx);
}
else if (normalElement->GetMappingMode() == FbxGeometryElement::eByControlPoint) {
normal = normalElement->GetDirectArray().GetAt(cpIdx);
}
vertex.normal = glm::vec3((float)normal[0], (float)normal[1], (float)normal[2]);*/
FbxVector4 normal;
if (mesh->GetPolygonVertexNormal(polyIdx, vertInPoly, normal)) {
vertex.normal = glm::vec3((float)normal[0], (float)normal[1], (float)normal[2]);
}
else {
vertex.normal = glm::vec3(0.0f);
}
}
else {
vertex.normal = glm::vec3(0.0f);
}
// UV
if (hasUV) {
FbxVector2 uv;
bool unmapped;
if (uvElement->GetMappingMode() == FbxGeometryElement::eByPolygonVertex) {
int uvIdx = mesh->GetTextureUVIndex(polyIdx, vertInPoly);
uv = uvElement->GetDirectArray().GetAt(uvIdx);
}
else if (uvElement->GetMappingMode() == FbxGeometryElement::eByControlPoint) {
uv = uvElement->GetDirectArray().GetAt(cpIdx);
}
vertex.uv = glm::vec2((float)uv[0], (float)uv[1]);
}
else {
vertex.uv = glm::vec2(0.0f);
}
vertices.push_back(vertex);
indices.push_back(static_cast<uint32_t>(indices.size())); // 简单索引（每个顶点独立）
}
}
}
// 获取根节点在给定时间的全局变换
glm::mat4 GetRootGlobalTransform(FbxTime time) {
FbxNode* root = scene->GetRootNode();
FbxAMatrix globalTransform = root->EvaluateGlobalTransform(time);
return FbxAMatrixToGlm(globalTransform);
}
glm::mat4 FbxAMatrixToGlm(const FbxAMatrix& m) {
glm::mat4 result;
for (int i = 0; i < 4; ++i)
for (int j = 0; j < 4; ++j)
result[i][j] = (float)m[i][j];
// FBX 是行主序？GLM 是列主序，但 FbxAMatrix 内部是行主序，这里需要转置
return glm::transpose(result);
}
FbxScene* scene = nullptr;
FbxAnimStack* currentAnimStack = nullptr;
FbxAnimLayer* currentAnimLayer = nullptr;
FbxTime currentTime;
FbxTime duration;
std::vector<Vertex> vertices;
std::vector<uint32_t> indices;
};
// ---------- 主函数 ----------
bool SetWindowIconFromResource(GLFWwindow* window, int resourceId) {
// 1. 加载图标资源
HICON hIcon = (HICON)LoadImage(
GetModuleHandle(NULL), // 当前模块句柄
MAKEINTRESOURCE(resourceId), // 资源 ID，例如 IDI_FBXVIEW
IMAGE_ICON, // 图像类型
0, 0, // 使用默认尺寸
LR_DEFAULTCOLOR
);
if (!hIcon) {
// 如果 LoadImage 失败，尝试 LoadIcon（只加载默认尺寸）
hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(resourceId));
if (!hIcon) {
fprintf(stderr, "Failed to load icon resource\n");
return false;
}
}
// 2. 获取图标尺寸和位图数据
ICONINFO iconInfo;
if (!GetIconInfo(hIcon, &iconInfo)) {
DestroyIcon(hIcon);
return false;
}
// 获取颜色位图的信息
BITMAP bmColor = { 0 };
if (iconInfo.hbmColor) {
GetObject(iconInfo.hbmColor, sizeof(BITMAP), &bmColor);
}
else {
// 如果没有颜色位图（单色图标），使用掩码位图尺寸
BITMAP bmMask;
GetObject(iconInfo.hbmMask, sizeof(BITMAP), &bmMask);
bmColor.bmWidth = bmMask.bmWidth;
bmColor.bmHeight = bmMask.bmHeight / 2; // 掩码高度通常是图标的两倍
}
int width = bmColor.bmWidth;
int height = bmColor.bmHeight;
// 3. 创建兼容 DC 并绘制图标到位图
HDC hdcScreen = GetDC(NULL);
HDC hdcMem = CreateCompatibleDC(hdcScreen);
HBITMAP hbmTemp = CreateCompatibleBitmap(hdcScreen, width, height);
HGDIOBJ oldBmp = SelectObject(hdcMem, hbmTemp);
// 清空背景（设为透明黑色）
RECT rect = { 0, 0, width, height };
HBRUSH hBrush = CreateSolidBrush(RGB(0, 0, 0));
FillRect(hdcMem, &rect, hBrush);
DeleteObject(hBrush);
// 绘制图标
DrawIconEx(hdcMem, 0, 0, hIcon, width, height, 0, NULL, DI_NORMAL);
// 4. 读取像素数据（BGRA 格式）
std::vector<unsigned char> pixels(width * height * 4);
BITMAPINFO bmi = { 0 };
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth = width;
bmi.bmiHeader.biHeight = -height; // 负值表示自上而下的行序
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 32;
bmi.bmiHeader.biCompression = BI_RGB;
GetDIBits(hdcMem, hbmTemp, 0, height, pixels.data(), &bmi, DIB_RGB_COLORS);
// 5. 清理 GDI 对象
SelectObject(hdcMem, oldBmp);
DeleteObject(hbmTemp);
DeleteDC(hdcMem);
ReleaseDC(NULL, hdcScreen);
DeleteObject(iconInfo.hbmColor);
DeleteObject(iconInfo.hbmMask);
DestroyIcon(hIcon);
// 6. 将 BGRA 转换为 RGBA（GLFW 要求 RGBA）
for (int i = 0; i < width * height; i++) {
unsigned char r = pixels[i * 4 + 2]; // B 在索引 0，R 在索引 2
unsigned char b = pixels[i * 4 + 0];
pixels[i * 4 + 0] = r;
pixels[i * 4 + 2] = b;
}
// 7. 设置 GLFW 窗口图标
GLFWimage iconImage;
iconImage.width = width;
iconImage.height = height;
iconImage.pixels = pixels.data(); // 指向 vector 的数据
glfwSetWindowIcon(window, 1, &iconImage);
// glfwSetWindowIcon 会复制像素数据，所以我们可以安全释放 vector
return true;
}
static bool rep = false; // 平移速度
static float speed = 0.01f; // 平移速度
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
_In_opt_ HINSTANCE hPrevInstance,
_In_ LPWSTR lpCmdLine,
_In_ int nCmdShow)
{
int argc;
LPWSTR* argv = CommandLineToArgvW(lpCmdLine, &argc);
if (argv == nullptr || argc < 1) {
msg(L"命令行参数错误");
return -1;
}
std::string filename;
if (argc >= 1 && argv[0] != nullptr) {
// 将宽字符转换为 UTF-8
int len = WideCharToMultiByte(CP_UTF8, 0, argv[0], -1, nullptr, 0, nullptr, nullptr);
if (len > 0) {
filename.resize(len);
WideCharToMultiByte(CP_UTF8, 0, argv[0], -1, &filename[0], len, nullptr, nullptr);
filename.pop_back(); // 去掉结尾的 '\0'
}
}
LocalFree(argv);
if (filename.empty()) {
msg(L"请将Fbx文件拖至此程序启动!");
return -1;
}
work_path = GetCurrentExeDirectory();
// 初始化 GLFW
glfwInit();
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "FBX Viewer", nullptr, nullptr);
SetWindowIconFromResource(window, IDI_FBXVIEW);
//glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
// 鼠标移动回调
glfwSetCursorPosCallback(window, [](GLFWwindow* w, double x, double y) {
if (rightMousePressed) {
rep = true;
double dx = x - lastX;
double dy = y - lastY;
camYaw -= dx * 0.005f;
camPitch += dy * 0.005f;
camPitch = glm::clamp(camPitch, -1.5f, 1.5f); // 限制俯仰角避免翻转
}
if (leftMousePressed) {
rep = true;
double dx = x - lastX;
double dy = y - lastY;
// 计算摄像机坐标系方向
glm::vec3 dir;
dir.x = cos(camPitch) * sin(camYaw);
dir.y = sin(camPitch);
dir.z = cos(camPitch) * cos(camYaw);
glm::vec3 right = -glm::normalize(glm::cross(dir, glm::vec3(0.0f, 1.0f, 0.0f)));
glm::vec3 up = -glm::normalize(glm::cross(right, dir));
if (super_sc)
speed = 1.0f;
else if (super_sc1)
speed = 0.001f;
else
speed = 0.01f;
camTarget += right * (static_cast<float>(-dx) * speed) + up * (static_cast<float>(dy) * speed);
}
lastX = x;
lastY = y;
});
// 鼠标按键回调
glfwSetMouseButtonCallback(window, [](GLFWwindow* w, int btn, int action, int mods) {
if (btn == GLFW_MOUSE_BUTTON_LEFT) {
leftMousePressed = (action == GLFW_PRESS);
if (leftMousePressed) {
glfwGetCursorPos(w, &lastX, &lastY); // 记录按下时的位置
}
}
if (btn == GLFW_MOUSE_BUTTON_RIGHT) {
rightMousePressed = (action == GLFW_PRESS);
if (rightMousePressed) {
glfwGetCursorPos(w, &lastX, &lastY);
}
}
});
// 滚轮回调（缩放）
glfwSetScrollCallback(window, [](GLFWwindow* w, double xoffset, double yoffset) {
if (super_sc) {
camRadius -= (float)yoffset * 10;
}
else {
if(super_sc1)
camRadius -= (float)yoffset * 0.01f;
else
camRadius -= (float)yoffset * 0.5f;
}
camRadius = glm::clamp(camRadius, 0.01f, 1000.0f);
rep = true;
});
// 键盘回调（ESC退出）
glfwSetKeyCallback(window, [](GLFWwindow* w, int key, int scancode, int action, int mods) {
if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) {
glfwSetWindowShouldClose(w, GLFW_TRUE);
}
if (key == GLFW_KEY_LEFT_CONTROL)
{
switch (action)
{
case GLFW_RELEASE:
super_sc = false;
break;
case GLFW_PRESS:
super_sc = true;
super_sc1 = false;
break;
}
}
if (key == GLFW_KEY_LEFT_ALT)
{
switch (action)
{
case GLFW_RELEASE:
super_sc1 = false;
break;
case GLFW_PRESS:
super_sc1 = true;
super_sc = false;
break;
}
}
});
// 加载 FBX
FBXLoader loader;
if (!loader.LoadScene(filename)) {
glfwTerminate();
return -1;
}
if (loader.vertices.empty()) {
msg(L"No mesh found in FBX file.");
glfwTerminate();
return -1;
}
// 初始化 Vulkan 渲染器
VulkanRenderer renderer;
try {
renderer.init(window);
renderer.loadModel(loader.vertices, loader.indices);
}
catch (const std::exception& e) {
msg(L"Vulkan initialization failed");
glfwTerminate();
return -1;
}
// 动画时间
auto startTime = std::chrono::high_resolution_clock::now();
float animTime = 0.0f;
rep = true;
long djs;
bool rel_out = false;
// 主循环
while (!glfwWindowShouldClose(window)) {
glfwPollEvents();
if (!rep)
{
if (rel_out)
{
Sleep(100);
continue;
}
if (time(NULL) > djs)
{
rel_out = true;
}
continue;
}
{
djs =time(NULL) + 2;
rep = false;
rel_out = false;
}
// 更新动画时间
//if (loader.currentAnimStack) {
// auto now = std::chrono::high_resolution_clock::now();
// float elapsed = std::chrono::duration<float>(now - startTime).count();
// animTime = fmod(elapsed, loader.duration.GetSecondCount()); // 循环播放
// loader.currentTime.SetSecondDouble(animTime);
//}
// 计算摄像机位置
glm::vec3 dir;
dir.x = cos(camPitch) * sin(camYaw);
dir.y = sin(camPitch);
dir.z = cos(camPitch) * cos(camYaw);
glm::vec3 camPos = camTarget + camRadius * dir;
// 构建视图矩阵
glm::mat4 view = glm::lookAt(camPos, camTarget, glm::vec3(0.0f, 1.0f, 0.0f));
// 投影矩阵
glm::mat4 proj = glm::perspective(glm::radians(45.0f), (float)WIDTH / (float)HEIGHT, 0.1f, 1000.0f);
proj[1][1] *= -1; // Vulkan NDC Y 轴向下
// 模型矩阵只包含动画变换（旋转已在摄像机中体现）
glm::mat4 model = loader.GetRootGlobalTransform(loader.currentTime);
UniformBufferObject ubo{};
ubo.model = model;
ubo.view = view;
ubo.proj = proj;
ubo.lightDir = glm::normalize(glm::vec3(1.0f, 2.0f, 1.0f)); // 固定光源方向
renderer.updateUniformBuffer(ubo, renderer.m_currentFrame);
renderer.drawFrame();
}
renderer.waitIdle();
glfwTerminate();
return 0;
}shader.frag
cpp
#version 450
layout(location = 0) in vec3 fragNormal;
layout(location = 1) in vec2 fragUV;
layout(location = 2) in vec3 fragLightDir;
layout(location = 0) out vec4 outColor;
void main() {
vec3 N = normalize(fragNormal);
vec3 L = normalize(-fragLightDir); // 假设光源方向指向光源，取反得到光线方向
float diff = max(dot(N, L), 0.0);
vec3 diffuse = vec3(1.0, 0.8, 0.6) * diff; // 简单漫反射颜色
vec3 ambient = vec3(0.1, 0.1, 0.1);
outColor = vec4(ambient + diffuse, 1.0);
}shader.vert
cpp
#version 450
layout(location = 0) in vec3 inPos;
layout(location = 1) in vec3 inNormal;
layout(location = 2) in vec2 inUV;
layout(binding = 0) uniform UniformBufferObject {
mat4 model;
mat4 view;
mat4 proj;
vec3 lightDir;
} ubo;
layout(location = 0) out vec3 fragNormal;
layout(location = 1) out vec2 fragUV;
layout(location = 2) out vec3 fragLightDir;
void main() {
gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPos, 1.0);
// 将法线变换到世界空间（若模型包含缩放，需使用法线矩阵，此处简化）
fragNormal = mat3(ubo.model) * inNormal;
fragUV = inUV;
fragLightDir = ubo.lightDir; // 光源方向在世界空间
}