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

Use createBuffer function from Vulkan device class

Browse source
This commit is contained in:
saschawillems 2017-01-07 20:46:28 +01:00
parent 927660680d
commit e573a4c244
15 changed files with 222 additions and 233 deletions
Download patch file Download diff file Expand all files Collapse all files

66
computeshader/computeshader.cpp
View file

@ -65,9 +65,9 @@ public:
uint32_t queueFamilyIndex; // Family index of the graphics queue, used for barriers
} compute;
struct {
vkMeshLoader::MeshBuffer quad;
} meshes;
vk::Buffer vertexBuffer;
vk::Buffer indexBuffer;
uint32_t indexCount;
vk::Buffer uniformBufferVS;
@ -105,8 +105,10 @@ public:
vkDestroyFence(device, compute.fence, nullptr);
vkDestroyCommandPool(device, compute.commandPool, nullptr);
vkMeshLoader::freeMeshBufferResources(device, &meshes.quad);
vertexBuffer.destroy();
indexBuffer.destroy();
uniformBufferVS.destroy();
textureLoader->destroyTexture(textureColorMap);
textureLoader->destroyTexture(textureComputeTarget);
}
@ -262,14 +264,14 @@ public:
vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);
VkDeviceSize offsets[1] = { 0 };
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &meshes.quad.vertices.buf, offsets);
vkCmdBindIndexBuffer(drawCmdBuffers[i], meshes.quad.indices.buf, 0, VK_INDEX_TYPE_UINT32);
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &vertexBuffer.buffer, offsets);
vkCmdBindIndexBuffer(drawCmdBuffers[i], indexBuffer.buffer, 0, VK_INDEX_TYPE_UINT32);
// Left (pre compute)
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, graphics.pipelineLayout, 0, 1, &graphics.descriptorSetPreCompute, 0, NULL);
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, graphics.pipeline);
vkCmdDrawIndexed(drawCmdBuffers[i], meshes.quad.indexCount, 1, 0, 0, 0);
vkCmdDrawIndexed(drawCmdBuffers[i], indexCount, 1, 0, 0, 0);
// Right (post compute)
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, graphics.pipelineLayout, 0, 1, &graphics.descriptorSetPostCompute, 0, NULL);
@ -277,7 +279,7 @@ public:
viewport.x = (float)width / 2.0f;
vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
vkCmdDrawIndexed(drawCmdBuffers[i], meshes.quad.indexCount, 1, 0, 0, 0);
vkCmdDrawIndexed(drawCmdBuffers[i], indexCount, 1, 0, 0, 0);
vkCmdEndRenderPass(drawCmdBuffers[i]);
@ -306,33 +308,35 @@ public:
// Setup vertices for a single uv-mapped quad
void generateQuad()
{
#define dim 1.0f
std::vector<Vertex> vertexBuffer =
// Setup vertices for a single uv-mapped quad made from two triangles
std::vector<Vertex> vertices =
{
{ { dim, dim, 0.0f }, { 1.0f, 1.0f } },
{ { -dim, dim, 0.0f }, { 0.0f, 1.0f } },
{ { -dim, -dim, 0.0f }, { 0.0f, 0.0f } },
{ { dim, -dim, 0.0f }, { 1.0f, 0.0f } }
{ { 1.0f, 1.0f, 0.0f }, { 1.0f, 1.0f } },
{ { -1.0f, 1.0f, 0.0f }, { 0.0f, 1.0f } },
{ { -1.0f, -1.0f, 0.0f }, { 0.0f, 0.0f } },
{ { 1.0f, -1.0f, 0.0f }, { 1.0f, 0.0f } }
};
#undef dim
createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
vertexBuffer.size() * sizeof(Vertex),
vertexBuffer.data(),
&meshes.quad.vertices.buf,
&meshes.quad.vertices.mem);
// Setup indices
std::vector<uint32_t> indexBuffer = { 0,1,2, 2,3,0 };
meshes.quad.indexCount = indexBuffer.size();
std::vector<uint32_t> indices = { 0,1,2, 2,3,0 };
indexCount = static_cast<uint32_t>(indices.size());
createBuffer(
// Create buffers
// For the sake of simplicity we won't stage the vertex data to the gpu memory
// Vertex buffer
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
&vertexBuffer,
vertices.size() * sizeof(Vertex),
vertices.data()));
// Index buffer
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
indexBuffer.size() * sizeof(uint32_t),
indexBuffer.data(),
&meshes.quad.indices.buf,
&meshes.quad.indices.mem);
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
&indexBuffer,
indices.size() * sizeof(uint32_t),
indices.data()));
}
void setupVertexDescriptions()
@ -354,14 +358,14 @@ public:
VERTEX_BUFFER_BIND_ID,
0,
VK_FORMAT_R32G32B32_SFLOAT,
0);
offsetof(Vertex, pos));
// Location 1 : Texture coordinates
vertices.attributeDescriptions[1] =
vkTools::initializers::vertexInputAttributeDescription(
VERTEX_BUFFER_BIND_ID,
1,
VK_FORMAT_R32G32_SFLOAT,
sizeof(float) * 3);
offsetof(Vertex, uv));
// Assign to vertex buffer
vertices.inputState = vkTools::initializers::pipelineVertexInputStateCreateInfo();

7
computeshader/computeshader.vcxproj
View file

@ -90,6 +90,13 @@
<ClInclude Include="..\base\vulkanexamplebase.h" />
<ClInclude Include="..\base\vulkantools.h" />
</ItemGroup>
<ItemGroup>
<None Include="..\data\shaders\computeshader\edgedetect.comp" />
<None Include="..\data\shaders\computeshader\emboss.comp" />
<None Include="..\data\shaders\computeshader\sharpen.comp" />
<None Include="..\data\shaders\computeshader\texture.frag" />
<None Include="..\data\shaders\computeshader\texture.vert" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>

17
computeshader/computeshader.vcxproj.filters
View file

@ -42,4 +42,21 @@
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<None Include="..\data\shaders\computeshader\edgedetect.comp">
<Filter>Shaders</Filter>
</None>
<None Include="..\data\shaders\computeshader\emboss.comp">
<Filter>Shaders</Filter>
</None>
<None Include="..\data\shaders\computeshader\sharpen.comp">
<Filter>Shaders</Filter>
</None>
<None Include="..\data\shaders\computeshader\texture.frag">
<Filter>Shaders</Filter>
</None>
<None Include="..\data\shaders\computeshader\texture.vert">
<Filter>Shaders</Filter>
</None>
</ItemGroup>
</Project>

13
data/shaders/deferred/deferred.vert
View file

@ -3,15 +3,6 @@
#extension GL_ARB_separate_shader_objects : enable
#extension GL_ARB_shading_language_420pack : enable
layout (location = 0) in vec3 inPos;
layout (location = 1) in vec2 inUV;
layout (binding = 0) uniform UBO
{
mat4 projection;
mat4 model;
} ubo;
layout (location = 0) out vec2 outUV;
out gl_PerVertex
@ -21,6 +12,6 @@ out gl_PerVertex
void main()
{
outUV = inUV;
gl_Position = ubo.projection * ubo.model * vec4(inPos.xyz, 1.0);
outUV = vec2((gl_VertexIndex << 1) & 2, gl_VertexIndex & 2);
gl_Position = vec4(outUV * 2.0f - 1.0f, 0.0f, 1.0f);
}

BIN
data/shaders/deferred/deferred.vert.spv
View file

Binary file not shown.

4
data/shaders/shadowmapping/scene.frag
View file

@ -11,6 +11,8 @@ layout (location = 2) in vec3 inViewVec;
layout (location = 3) in vec3 inLightVec;
layout (location = 4) in vec4 inShadowCoord;
layout (constant_id = 0) const int enablePCF = 0;
layout (location = 0) out vec4 outFragColor;
#define ambient 0.1
@ -55,7 +57,7 @@ float filterPCF(vec4 sc)
void main()
{
float shadow = filterPCF(inShadowCoord / inShadowCoord.w);
float shadow = (enablePCF == 1) ? filterPCF(inShadowCoord / inShadowCoord.w) : textureProj(inShadowCoord / inShadowCoord.w, vec2(0.0));
vec3 N = normalize(inNormal);
vec3 L = normalize(inLightVec);

BIN
data/shaders/shadowmapping/scene.frag.spv
View file

Binary file not shown.

42
debugmarker/debugmarker.cpp
View file

@ -574,39 +574,37 @@ public:
// Create staging buffers
// Vertex data
createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
vertexBufferSize,
vertexBuffer.data(),
&vertexStaging.buffer,
&vertexStaging.memory);
&vertexStaging.memory,
vertexBuffer.data()));
// Index data
createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
indexBufferSize,
indexBuffer.data(),
&indexStaging.buffer,
&indexStaging.memory);
&indexStaging.memory,
indexBuffer.data()));
// Create device local buffers
// Vertex buffer
createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
vertexBufferSize,
nullptr,
&scene->vertices.buf,
&scene->vertices.mem);
&scene->vertices.mem));
// Index buffer
createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
indexBufferSize,
nullptr,
&scene->indices.buf,
&scene->indices.mem);
&scene->indices.mem));
// Copy from staging buffers
VkCommandBuffer copyCmd = VulkanExampleBase::createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
@ -639,21 +637,21 @@ public:
else
{
// Vertex buffer
createBuffer(
vulkanDevice->createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
vertexBufferSize,
vertexBuffer.data(),
&scene->vertices.buf,
&scene->vertices.mem);
&scene->vertices.mem,
vertexBuffer.data());
// Index buffer
createBuffer(
vulkanDevice->createBuffer(
VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
indexBufferSize,
indexBuffer.data(),
&scene->indices.buf,
&scene->indices.mem);
&scene->indices.mem,
indexBuffer.data());
}
delete(meshLoader);

14
deferredshadows/deferredshadows.cpp
View file

@ -519,12 +519,13 @@ public:
vertexBuffer.push_back({ { 0.0f, 0.0f, 0.0f },{ 0.0f, 0.0f },{ 1.0f, 1.0f, 1.0f },{ 0.0f, 0.0f, 0.0f } });
vertexBuffer.push_back({ { 1.0f, 0.0f, 0.0f },{ 1.0f, 0.0f },{ 1.0f, 1.0f, 1.0f },{ 0.0f, 0.0f, 0.0f } });
createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
vertexBuffer.size() * sizeof(Vertex),
vertexBuffer.data(),
&meshes.quad.vertices.buf,
&meshes.quad.vertices.mem);
&meshes.quad.vertices.mem,
vertexBuffer.data()));
// Setup indices
std::vector<uint32_t> indexBuffer = { 0,1,2, 2,3,0 };
@ -538,12 +539,13 @@ public:
}
meshes.quad.indexCount = static_cast<uint32_t>(indexBuffer.size());
createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
indexBuffer.size() * sizeof(uint32_t),
indexBuffer.data(),
&meshes.quad.indices.buf,
&meshes.quad.indices.mem);
&meshes.quad.indices.mem,
indexBuffer.data()));
}
void setupVertexDescriptions()

74
distancefieldfonts/distancefieldfonts.cpp
View file

@ -70,18 +70,14 @@ public:
} textures;
struct {
VkBuffer buf;
VkDeviceMemory mem;
VkPipelineVertexInputStateCreateInfo inputState;
std::vector<VkVertexInputBindingDescription> bindingDescriptions;
std::vector<VkVertexInputAttributeDescription> attributeDescriptions;
} vertices;
struct {
int count;
VkBuffer buf;
VkDeviceMemory mem;
} indices;
vk::Buffer vertexBuffer;
vk::Buffer indexBuffer;
uint32_t indexCount;
struct {
vk::Buffer vs;
@ -129,15 +125,13 @@ public:
textureLoader->destroyTexture(textures.fontBitmap);
vkDestroyPipeline(device, pipelines.sdf, nullptr);
vkDestroyPipeline(device, pipelines.bitmap, nullptr);
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
vkDestroyBuffer(device, vertices.buf, nullptr);
vkFreeMemory(device, vertices.mem, nullptr);
vkDestroyBuffer(device, indices.buf, nullptr);
vkFreeMemory(device, indices.mem, nullptr);
vertexBuffer.destroy();
indexBuffer.destroy();
uniformBuffers.vs.destroy();
uniformBuffers.fs.destroy();
@ -260,9 +254,9 @@ public:
// Signed distance field font
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSets.sdf, 0, NULL);
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.sdf);
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &vertices.buf, offsets);
vkCmdBindIndexBuffer(drawCmdBuffers[i], indices.buf, 0, VK_INDEX_TYPE_UINT32);
vkCmdDrawIndexed(drawCmdBuffers[i], indices.count, 1, 0, 0, 0);
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &vertexBuffer.buffer, offsets);
vkCmdBindIndexBuffer(drawCmdBuffers[i], indexBuffer.buffer, 0, VK_INDEX_TYPE_UINT32);
vkCmdDrawIndexed(drawCmdBuffers[i], indexCount, 1, 0, 0, 0);
// Linear filtered bitmap font
if (splitScreen)
@ -271,9 +265,7 @@ public:
vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSets.bitmap, 0, NULL);
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.bitmap);
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &vertices.buf, offsets);
vkCmdBindIndexBuffer(drawCmdBuffers[i], indices.buf, 0, VK_INDEX_TYPE_UINT32);
vkCmdDrawIndexed(drawCmdBuffers[i], indices.count, 1, 0, 0, 0);
vkCmdDrawIndexed(drawCmdBuffers[i], indexCount, 1, 0, 0, 0);
}
vkCmdEndRenderPass(drawCmdBuffers[i]);
@ -285,8 +277,8 @@ public:
// Creates a vertex buffer containing quads for the passed text
void generateText(std:: string text)
{
std::vector<Vertex> vertexBuffer;
std::vector<uint32_t> indexBuffer;
std::vector<Vertex> vertices;
std::vector<uint32_t> indices;
uint32_t indexOffset = 0;
float w = textures.fontSDF.width;
@ -315,43 +307,45 @@ public:
float xo = charInfo->xoffset / 36.0f;
float yo = charInfo->yoffset / 36.0f;
vertexBuffer.push_back({ { posx + dimx + xo, posy + dimy, 0.0f }, { ue, te } });
vertexBuffer.push_back({ { posx + xo, posy + dimy, 0.0f }, { us, te } });
vertexBuffer.push_back({ { posx + xo, posy, 0.0f }, { us, ts } });
vertexBuffer.push_back({ { posx + dimx + xo, posy, 0.0f }, { ue, ts } });
vertices.push_back({ { posx + dimx + xo, posy + dimy, 0.0f }, { ue, te } });
vertices.push_back({ { posx + xo, posy + dimy, 0.0f }, { us, te } });
vertices.push_back({ { posx + xo, posy, 0.0f }, { us, ts } });
vertices.push_back({ { posx + dimx + xo, posy, 0.0f }, { ue, ts } });
std::array<uint32_t, 6> indices = { 0,1,2, 2,3,0 };
for (auto& index : indices)
std::array<uint32_t, 6> letterIndices = { 0,1,2, 2,3,0 };
for (auto& index : letterIndices)
{
indexBuffer.push_back(indexOffset + index);
indices.push_back(indexOffset + index);
}
indexOffset += 4;
float advance = ((float)(charInfo->xadvance) / 36.0f);
posx += advance;
}
indices.count = indexBuffer.size();
indexCount = indices.size();
// Center
for (auto& v : vertexBuffer)
for (auto& v : vertices)
{
v.pos[0] -= posx / 2.0f;
v.pos[1] -= 0.5f;
}
createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
vertexBuffer.size() * sizeof(Vertex),
vertexBuffer.data(),
&vertices.buf,
&vertices.mem);
// Generate device local buffers for the text vertices and indices and upload the data
createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
&vertexBuffer,
vertices.size() * sizeof(Vertex),
vertices.data()));
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
indexBuffer.size() * sizeof(uint32_t),
indexBuffer.data(),
&indices.buf,
&indices.mem);
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
&indexBuffer,
indices.size() * sizeof(uint32_t),
indices.data()));
}
void setupVertexDescriptions()

13
instancing/instancing.cpp
View file

@ -460,21 +460,20 @@ public:
VkBuffer buffer;
} stagingBuffer;
VulkanExampleBase::createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
instanceBuffer.size,
instanceData.data(),
&stagingBuffer.buffer,
&stagingBuffer.memory);
&stagingBuffer.memory,
instanceData.data()));
VulkanExampleBase::createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
instanceBuffer.size,
nullptr,
&instanceBuffer.buffer,
&instanceBuffer.memory);
&instanceBuffer.memory));
// Copy to staging buffer
VkCommandBuffer copyCmd = VulkanExampleBase::createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);

38
mesh/mesh.cpp
View file

@ -234,39 +234,37 @@ public:
// Create staging buffers
// Vertex data
createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
vertexBufferSize,
vertexBuffer.data(),
&vertexStaging.buffer,
&vertexStaging.memory);
&vertexStaging.memory,
vertexBuffer.data()));
// Index data
createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
indexBufferSize,
indexBuffer.data(),
&indexStaging.buffer,
&indexStaging.memory);
&indexStaging.memory,
indexBuffer.data()));
// Create device local buffers
// Vertex buffer
createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
vertexBufferSize,
nullptr,
&mesh.vertices.buf,
&mesh.vertices.mem);
&mesh.vertices.mem));
// Index buffer
createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
indexBufferSize,
nullptr,
&mesh.indices.buf,
&mesh.indices.mem);
&mesh.indices.mem));
// Copy from staging buffers
VkCommandBuffer copyCmd = VulkanExampleBase::createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
@ -299,21 +297,21 @@ public:
else
{
// Vertex buffer
createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
vertexBufferSize,
vertexBuffer.data(),
&mesh.vertices.buf,
&mesh.vertices.mem);
&mesh.vertices.mem,
vertexBuffer.data()));
// Index buffer
createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
indexBufferSize,
indexBuffer.data(),
&mesh.indices.buf,
&mesh.indices.mem);
&mesh.indices.mem,
indexBuffer.data()));
}
delete(meshLoader);

14
offscreen/offscreen.cpp
View file

@ -502,23 +502,25 @@ public:
};
#undef QUAD_COLOR_NORMAL
createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
vertexBuffer.size() * sizeof(Vertex),
vertexBuffer.data(),
&meshes.quad.vertices.buf,
&meshes.quad.vertices.mem);
&meshes.quad.vertices.mem,
vertexBuffer.data()));
// Setup indices
std::vector<uint32_t> indexBuffer = { 0,1,2, 2,3,0 };
meshes.quad.indexCount = indexBuffer.size();
createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
indexBuffer.size() * sizeof(uint32_t),
indexBuffer.data(),
&meshes.quad.indices.buf,
&meshes.quad.indices.mem);
&meshes.quad.indices.mem,
indexBuffer.data()));
}
void setupVertexDescriptions()

7
particlefire/particlefire.cpp
View file

@ -278,12 +278,13 @@ public:
particles.size = particleBuffer.size() * sizeof(Particle);
createBuffer(
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
particles.size,
particleBuffer.data(),
&particles.buffer,
&particles.memory);
&particles.memory,
particleBuffer.data()));
// Map the memory and store the pointer for reuse
VK_CHECK_RESULT(vkMapMemory(device, particles.memory, 0, particles.size, 0, &particles.mappedMemory));

142
skeletalanimation/skeletalanimation.cpp
View file

@ -552,98 +552,72 @@ public:
VkDeviceSize indexBufferSize = indexBuffer.size() * sizeof(uint32_t);
skinnedMesh->meshBuffer.indexCount = indexBuffer.size();
bool useStaging = true;
struct {
VkBuffer buffer;
VkDeviceMemory memory;
} vertexStaging, indexStaging;
if (useStaging)
{
struct {
VkBuffer buffer;
VkDeviceMemory memory;
} vertexStaging, indexStaging;
// Create staging buffers
// Vertex data
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
vertexBufferSize,
&vertexStaging.buffer,
&vertexStaging.memory,
vertexBuffer.data()));
// Index data
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
indexBufferSize,
&indexStaging.buffer,
&indexStaging.memory,
indexBuffer.data()));
// Create staging buffers
// Vertex data
createBuffer(
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
vertexBufferSize,
vertexBuffer.data(),
&vertexStaging.buffer,
&vertexStaging.memory);
// Index data
createBuffer(
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
indexBufferSize,
indexBuffer.data(),
&indexStaging.buffer,
&indexStaging.memory);
// Create device local buffers
// Vertex buffer
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
vertexBufferSize,
&skinnedMesh->meshBuffer.vertices.buf,
&skinnedMesh->meshBuffer.vertices.mem));
// Index buffer
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
indexBufferSize,
&skinnedMesh->meshBuffer.indices.buf,
&skinnedMesh->meshBuffer.indices.mem));
// Create device local buffers
// Vertex buffer
createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
vertexBufferSize,
nullptr,
&skinnedMesh->meshBuffer.vertices.buf,
&skinnedMesh->meshBuffer.vertices.mem);
// Index buffer
createBuffer(
VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
indexBufferSize,
nullptr,
&skinnedMesh->meshBuffer.indices.buf,
&skinnedMesh->meshBuffer.indices.mem);
// Copy from staging buffers
VkCommandBuffer copyCmd = VulkanExampleBase::createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
// Copy from staging buffers
VkCommandBuffer copyCmd = VulkanExampleBase::createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
VkBufferCopy copyRegion = {};
VkBufferCopy copyRegion = {};
copyRegion.size = vertexBufferSize;
vkCmdCopyBuffer(
copyCmd,
vertexStaging.buffer,
skinnedMesh->meshBuffer.vertices.buf,
1,
&copyRegion);
copyRegion.size = vertexBufferSize;
vkCmdCopyBuffer(
copyCmd,
vertexStaging.buffer,
skinnedMesh->meshBuffer.vertices.buf,
1,
&copyRegion);
copyRegion.size = indexBufferSize;
vkCmdCopyBuffer(
copyCmd,
indexStaging.buffer,
skinnedMesh->meshBuffer.indices.buf,
1,
&copyRegion);
copyRegion.size = indexBufferSize;
vkCmdCopyBuffer(
copyCmd,
indexStaging.buffer,
skinnedMesh->meshBuffer.indices.buf,
1,
&copyRegion);
VulkanExampleBase::flushCommandBuffer(copyCmd, queue, true);
VulkanExampleBase::flushCommandBuffer(copyCmd, queue, true);
vkDestroyBuffer(device, vertexStaging.buffer, nullptr);
vkFreeMemory(device, vertexStaging.memory, nullptr);
vkDestroyBuffer(device, indexStaging.buffer, nullptr);
vkFreeMemory(device, indexStaging.memory, nullptr);
}
else
{
// Vertex buffer
createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
vertexBufferSize,
vertexBuffer.data(),
&skinnedMesh->meshBuffer.vertices.buf,
&skinnedMesh->meshBuffer.vertices.mem);
// Index buffer
createBuffer(
VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
indexBufferSize,
indexBuffer.data(),
&skinnedMesh->meshBuffer.indices.buf,
&skinnedMesh->meshBuffer.indices.mem);
}
vkDestroyBuffer(device, vertexStaging.buffer, nullptr);
vkFreeMemory(device, vertexStaging.memory, nullptr);
vkDestroyBuffer(device, indexStaging.buffer, nullptr);
vkFreeMemory(device, indexStaging.memory, nullptr);
}
void loadAssets()