claude_code/procedural-3d-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Code cleanup, comments

Browse source
This commit is contained in:
Sascha Willems 2024-01-03 20:16:41 +01:00
parent d8a3379e0b
commit a63d2e0168
2 changed files with 94 additions and 152 deletions
Download patch file Download diff file Expand all files Collapse all files

156
examples/pushconstants/pushconstants.cpp
View file

@ -1,7 +1,7 @@
/* /*
* Vulkan Example - Push constants example (small shader block accessed outside of uniforms for fast updates) * Vulkan Example - Push constants example (small shader block accessed outside of uniforms for fast updates)
* *
* Copyright (C) 2016 by Sascha Willems - www.saschawillems.de * Copyright (C) 2016-2023 by Sascha Willems - www.saschawillems.de
* *
* This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT) * This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
*/ */
@ -16,12 +16,6 @@
#include "vulkanexamplebase.h" #include "vulkanexamplebase.h"
#include "VulkanglTFModel.h" #include "VulkanglTFModel.h"
#define VERTEX_BUFFER_BIND_ID 0
float rnd()
{
return static_cast<float>(rand()) / static_cast<float>(RAND_MAX);
}
class VulkanExample : public VulkanExampleBase class VulkanExample : public VulkanExampleBase
{ {
public: public:
@ -34,18 +28,17 @@ public:
}; };
std::array<SpherePushConstantData, 16> spheres; std::array<SpherePushConstantData, 16> spheres;
vks::Buffer uniformBuffer; struct UniformData {
struct UBOMatrices {
glm::mat4 projection; glm::mat4 projection;
glm::mat4 model; glm::mat4 model;
glm::mat4 view; glm::mat4 view;
} uboMatrices; } uniformData;
vks::Buffer uniformBuffer;
VkPipeline pipeline; VkPipeline pipeline{ VK_NULL_HANDLE };
VkPipelineLayout pipelineLayout; VkPipelineLayout pipelineLayout{ VK_NULL_HANDLE };
VkDescriptorSet descriptorSet; VkDescriptorSet descriptorSet{ VK_NULL_HANDLE };
VkDescriptorSetLayout descriptorSetLayout; VkDescriptorSetLayout descriptorSetLayout{ VK_NULL_HANDLE };
VulkanExample() : VulkanExampleBase() VulkanExample() : VulkanExampleBase()
{ {
@ -59,21 +52,22 @@ public:
~VulkanExample() ~VulkanExample()
{ {
// Clean up used Vulkan resources if (device) {
// Note : Inherited destructor cleans up resources stored in base class vkDestroyPipeline(device, pipeline, nullptr);
vkDestroyPipeline(device, pipeline, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
vkDestroyPipelineLayout(device, pipelineLayout, nullptr); uniformBuffer.destroy();
vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); }
uniformBuffer.destroy();
} }
void setupSpheres() void setupSpheres()
{ {
// Setup random colors and fixed positions for every spheres in the scene // Setup random colors and fixed positions for every sphere in the scene
std::random_device rndDevice;
std::default_random_engine rndEngine(rndDevice());
std::uniform_real_distribution<float> rndDist(0.1f, 1.0f);
for (uint32_t i = 0; i < spheres.size(); i++) { for (uint32_t i = 0; i < spheres.size(); i++) {
spheres[i].color = glm::vec4(rnd(), rnd(), rnd(), 1.0f); spheres[i].color = glm::vec4(rndDist(rndEngine), rndDist(rndEngine), rndDist(rndEngine), 1.0f);
const float rad = glm::radians(i * 360.0f / static_cast<uint32_t>(spheres.size())); const float rad = glm::radians(i * 360.0f / static_cast<uint32_t>(spheres.size()));
spheres[i].position = glm::vec4(glm::vec3(sin(rad), cos(rad), 0.0f) * 3.5f, 1.0f); spheres[i].position = glm::vec4(glm::vec3(sin(rad), cos(rad), 0.0f) * 3.5f, 1.0f);
} }
@ -98,7 +92,6 @@ public:
for (int32_t i = 0; i < drawCmdBuffers.size(); ++i) for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)
{ {
// Set target frame buffer
renderPassBeginInfo.framebuffer = frameBuffers[i]; renderPassBeginInfo.framebuffer = frameBuffers[i];
VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo)); VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));
@ -142,64 +135,47 @@ public:
model.loadFromFile(getAssetPath() + "models/sphere.gltf", vulkanDevice, queue, glTFLoadingFlags); model.loadFromFile(getAssetPath() + "models/sphere.gltf", vulkanDevice, queue, glTFLoadingFlags);
} }
void setupDescriptorPool() void setupDescriptors()
{ {
// Pool
std::vector<VkDescriptorPoolSize> poolSizes = { std::vector<VkDescriptorPoolSize> poolSizes = {
vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1), vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1),
}; };
VkDescriptorPoolCreateInfo descriptorPoolInfo = vks::initializers::descriptorPoolCreateInfo(poolSizes, 2); VkDescriptorPoolCreateInfo descriptorPoolInfo = vks::initializers::descriptorPoolCreateInfo(poolSizes, 2);
VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool)); VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));
// Layout
std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = {
vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT, 0),
};
VkDescriptorSetLayoutCreateInfo descriptorLayout = vks::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings);
VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));
// Set
VkDescriptorSetAllocateInfo allocInfo = vks::initializers::descriptorSetAllocateInfo(descriptorPool, &descriptorSetLayout, 1);
VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));
VkWriteDescriptorSet writeDescriptorSet = vks::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &uniformBuffer.descriptor);
vkUpdateDescriptorSets(device, 1, &writeDescriptorSet, 0, nullptr);
} }
void setupDescriptorSetLayout() void preparePipelines()
{ {
std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = { // Layout
// Binding 0 : Vertex shader uniform buffer // [POI] Define the push constant range used by the pipeline layout
vks::initializers::descriptorSetLayoutBinding(
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
VK_SHADER_STAGE_VERTEX_BIT,
0),
};
VkDescriptorSetLayoutCreateInfo descriptorLayout = vks::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings);
VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));
// Define the push constant range used by the pipeline layout
// Note that the spec only requires a minimum of 128 bytes, so for passing larger blocks of data you'd use UBOs or SSBOs // Note that the spec only requires a minimum of 128 bytes, so for passing larger blocks of data you'd use UBOs or SSBOs
VkPushConstantRange pushConstantRange{}; VkPushConstantRange pushConstantRange{};
// Push constants will only be accessible at the selected pipeline stages, for this sample it's the vertex shader that reads them
pushConstantRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; pushConstantRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
pushConstantRange.offset = 0; pushConstantRange.offset = 0;
pushConstantRange.size = sizeof(SpherePushConstantData); pushConstantRange.size = sizeof(SpherePushConstantData);
VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vks::initializers::pipelineLayoutCreateInfo(&descriptorSetLayout, 1); VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vks::initializers::pipelineLayoutCreateInfo(&descriptorSetLayout, 1);
pipelineLayoutCreateInfo.pushConstantRangeCount = 1; pipelineLayoutCreateInfo.pushConstantRangeCount = 1;
pipelineLayoutCreateInfo.pPushConstantRanges = &pushConstantRange; pipelineLayoutCreateInfo.pPushConstantRanges = &pushConstantRange;
VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout)); VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout));
}
void setupDescriptorSet() // Pipeline
{
VkDescriptorSetAllocateInfo allocInfo =
vks::initializers::descriptorSetAllocateInfo(
descriptorPool,
&descriptorSetLayout,
1);
VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));
// Binding 0 : Vertex shader uniform buffer
VkWriteDescriptorSet writeDescriptorSet =
vks::initializers::writeDescriptorSet(
descriptorSet,
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
0,
&uniformBuffer.descriptor);
vkUpdateDescriptorSets(device, 1, &writeDescriptorSet, 0, NULL);
}
void preparePipelines()
{
VkPipelineInputAssemblyStateCreateInfo inputAssemblyState = vks::initializers::pipelineInputAssemblyStateCreateInfo(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE); VkPipelineInputAssemblyStateCreateInfo inputAssemblyState = vks::initializers::pipelineInputAssemblyStateCreateInfo(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE);
VkPipelineRasterizationStateCreateInfo rasterizationState = vks::initializers::pipelineRasterizationStateCreateInfo(VK_POLYGON_MODE_FILL, VK_CULL_MODE_BACK_BIT, VK_FRONT_FACE_COUNTER_CLOCKWISE, 0); VkPipelineRasterizationStateCreateInfo rasterizationState = vks::initializers::pipelineRasterizationStateCreateInfo(VK_POLYGON_MODE_FILL, VK_CULL_MODE_BACK_BIT, VK_FRONT_FACE_COUNTER_CLOCKWISE, 0);
VkPipelineColorBlendAttachmentState blendAttachmentState = vks::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE); VkPipelineColorBlendAttachmentState blendAttachmentState = vks::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE);
@ -229,39 +205,17 @@ public:
void prepareUniformBuffers() void prepareUniformBuffers()
{ {
// Vertex shader uniform buffer block VK_CHECK_RESULT(vulkanDevice->createBuffer(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &uniformBuffer, sizeof(UniformData)));
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
&uniformBuffer,
sizeof(uboMatrices)));
// Map persistent
VK_CHECK_RESULT(uniformBuffer.map()); VK_CHECK_RESULT(uniformBuffer.map());
updateUniformBuffers(); updateUniformBuffers();
} }
void updateUniformBuffers() void updateUniformBuffers()
{ {
uboMatrices.projection = camera.matrices.perspective; uniformData.projection = camera.matrices.perspective;
uboMatrices.view = camera.matrices.view; uniformData.view = camera.matrices.view;
uboMatrices.model = glm::scale(glm::mat4(1.0f), glm::vec3(0.5f)); uniformData.model = glm::scale(glm::mat4(1.0f), glm::vec3(0.5f));
memcpy(uniformBuffer.mapped, &uboMatrices, sizeof(uboMatrices)); memcpy(uniformBuffer.mapped, &uniformData, sizeof(UniformData));
}
void draw()
{
VulkanExampleBase::prepareFrame();
// Command buffer to be submitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit to queue
VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
VulkanExampleBase::submitFrame();
} }
void prepare() void prepare()
@ -270,23 +224,27 @@ public:
loadAssets(); loadAssets();
setupSpheres(); setupSpheres();
prepareUniformBuffers(); prepareUniformBuffers();
setupDescriptorSetLayout(); setupDescriptors();
preparePipelines(); preparePipelines();
setupDescriptorPool();
setupDescriptorSet();
buildCommandBuffers(); buildCommandBuffers();
prepared = true; prepared = true;
} }
void draw()
{
VulkanExampleBase::prepareFrame();
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
VulkanExampleBase::submitFrame();
}
virtual void render() virtual void render()
{ {
if (!prepared) if (!prepared)
return; return;
updateUniformBuffers();
draw(); draw();
if (!camera.updated)
{
updateUniformBuffers();
}
} }
}; };

90
examples/pushdescriptors/pushdescriptors.cpp
View file

@ -8,7 +8,7 @@
* this example uses push descriptors to pass descriptor sets for per-model textures and matrices * this example uses push descriptors to pass descriptor sets for per-model textures and matrices
* at command buffer creation time. * at command buffer creation time.
* *
* Copyright (C) 2018 by Sascha Willems - www.saschawillems.de * Copyright (C) 2018-2023 by Sascha Willems - www.saschawillems.de
* *
* This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT) * This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
*/ */
@ -21,7 +21,7 @@ class VulkanExample : public VulkanExampleBase
public: public:
bool animate = true; bool animate = true;
PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR; PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR{ VK_NULL_HANDLE };
VkPhysicalDevicePushDescriptorPropertiesKHR pushDescriptorProps{}; VkPhysicalDevicePushDescriptorPropertiesKHR pushDescriptorProps{};
struct Cube { struct Cube {
@ -34,18 +34,15 @@ public:
vkglTF::Model model; vkglTF::Model model;
struct UniformBuffers { struct UniformData {
vks::Buffer scene;
} uniformBuffers;
struct UboScene {
glm::mat4 projection; glm::mat4 projection;
glm::mat4 view; glm::mat4 view;
} uboScene; } uniformData;
vks::Buffer uniformBuffer;
VkPipeline pipeline; VkPipeline pipeline{ VK_NULL_HANDLE };
VkPipelineLayout pipelineLayout; VkPipelineLayout pipelineLayout{ VK_NULL_HANDLE };
VkDescriptorSetLayout descriptorSetLayout; VkDescriptorSetLayout descriptorSetLayout{ VK_NULL_HANDLE };
VulkanExample() : VulkanExampleBase() VulkanExample() : VulkanExampleBase()
{ {
@ -61,14 +58,16 @@ public:
~VulkanExample() ~VulkanExample()
{ {
vkDestroyPipeline(device, pipeline, nullptr); if (device) {
vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyPipeline(device, pipeline, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
for (auto cube : cubes) { vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
cube.uniformBuffer.destroy(); for (auto cube : cubes) {
cube.texture.destroy(); cube.uniformBuffer.destroy();
cube.texture.destroy();
}
uniformBuffer.destroy();
} }
uniformBuffers.scene.destroy();
} }
virtual void getEnabledFeatures() virtual void getEnabledFeatures()
@ -113,7 +112,7 @@ public:
model.bindBuffers(drawCmdBuffers[i]); model.bindBuffers(drawCmdBuffers[i]);
// Render two cubes using different descriptor sets using push descriptors // Render two cubes using different descriptor sets using push descriptors
for (auto cube : cubes) { for (const auto& cube : cubes) {
// Instead of preparing the descriptor sets up-front, using push descriptors we can set (push) them inside of a command buffer // Instead of preparing the descriptor sets up-front, using push descriptors we can set (push) them inside of a command buffer
// This allows a more dynamic approach without the need to create descriptor sets for each model // This allows a more dynamic approach without the need to create descriptor sets for each model
@ -127,7 +126,7 @@ public:
writeDescriptorSets[0].dstBinding = 0; writeDescriptorSets[0].dstBinding = 0;
writeDescriptorSets[0].descriptorCount = 1; writeDescriptorSets[0].descriptorCount = 1;
writeDescriptorSets[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; writeDescriptorSets[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
writeDescriptorSets[0].pBufferInfo = &uniformBuffers.scene.descriptor; writeDescriptorSets[0].pBufferInfo = &uniformBuffer.descriptor;
// Model matrices // Model matrices
writeDescriptorSets[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; writeDescriptorSets[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
@ -196,7 +195,7 @@ public:
VkPipelineViewportStateCreateInfo viewportStateCI = vks::initializers::pipelineViewportStateCreateInfo(1, 1, 0); VkPipelineViewportStateCreateInfo viewportStateCI = vks::initializers::pipelineViewportStateCreateInfo(1, 1, 0);
VkPipelineMultisampleStateCreateInfo multisampleStateCI = vks::initializers::pipelineMultisampleStateCreateInfo(VK_SAMPLE_COUNT_1_BIT, 0); VkPipelineMultisampleStateCreateInfo multisampleStateCI = vks::initializers::pipelineMultisampleStateCreateInfo(VK_SAMPLE_COUNT_1_BIT, 0);
const std::vector<VkDynamicState> dynamicStateEnables = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR }; const std::vector<VkDynamicState> dynamicStateEnables = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
VkPipelineDynamicStateCreateInfo dynamicStateCI = vks::initializers::pipelineDynamicStateCreateInfo(dynamicStateEnables.data(), static_cast<uint32_t>(dynamicStateEnables.size()),0); VkPipelineDynamicStateCreateInfo dynamicStateCI = vks::initializers::pipelineDynamicStateCreateInfo(dynamicStateEnables);
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages; std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
VkGraphicsPipelineCreateInfo pipelineCI = vks::initializers::pipelineCreateInfo(pipelineLayout, renderPass, 0); VkGraphicsPipelineCreateInfo pipelineCI = vks::initializers::pipelineCreateInfo(pipelineLayout, renderPass, 0);
@ -219,20 +218,12 @@ public:
void prepareUniformBuffers() void prepareUniformBuffers()
{ {
// Vertex shader scene uniform buffer block // Vertex shader scene uniform buffer block
VK_CHECK_RESULT(vulkanDevice->createBuffer( VK_CHECK_RESULT(vulkanDevice->createBuffer(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &uniformBuffer, sizeof(UniformData)));
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_CHECK_RESULT(uniformBuffer.map());
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
&uniformBuffers.scene,
sizeof(UboScene)));
VK_CHECK_RESULT(uniformBuffers.scene.map());
// Vertex shader cube model uniform buffer blocks // Vertex shader cube model uniform buffer blocks
for (auto& cube : cubes) { for (auto& cube : cubes) {
VK_CHECK_RESULT(vulkanDevice->createBuffer( VK_CHECK_RESULT(vulkanDevice->createBuffer(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &cube.uniformBuffer, sizeof(glm::mat4)));
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
&cube.uniformBuffer,
sizeof(glm::mat4)));
VK_CHECK_RESULT(cube.uniformBuffer.map()); VK_CHECK_RESULT(cube.uniformBuffer.map());
} }
@ -242,9 +233,9 @@ public:
void updateUniformBuffers() void updateUniformBuffers()
{ {
uboScene.projection = camera.matrices.perspective; uniformData.projection = camera.matrices.perspective;
uboScene.view = camera.matrices.view; uniformData.view = camera.matrices.view;
memcpy(uniformBuffers.scene.mapped, &uboScene, sizeof(UboScene)); memcpy(uniformBuffer.mapped, &uniformData, sizeof(uniformData));
} }
void updateCubeUniformBuffers() void updateCubeUniformBuffers()
@ -270,15 +261,6 @@ public:
} }
} }
void draw()
{
VulkanExampleBase::prepareFrame();
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
VulkanExampleBase::submitFrame();
}
void prepare() void prepare()
{ {
VulkanExampleBase::prepare(); VulkanExampleBase::prepare();
@ -316,22 +298,24 @@ public:
prepared = true; prepared = true;
} }
void draw()
{
VulkanExampleBase::prepareFrame();
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
VulkanExampleBase::submitFrame();
}
virtual void render() virtual void render()
{ {
if (!prepared) if (!prepared)
return; return;
draw(); updateUniformBuffers();
if (animate && !paused) { if (animate && !paused) {
updateCubeUniformBuffers(); updateCubeUniformBuffers();
} }
if (camera.updated) { draw();
updateUniformBuffers();
}
}
virtual void viewChanged()
{
updateUniformBuffers();
} }
virtual void OnUpdateUIOverlay(vks::UIOverlay *overlay) virtual void OnUpdateUIOverlay(vks::UIOverlay *overlay)