// Prepare and initialize uniform buffer containing shader uniforms
void prepareUniformBuffers()
{
// Phong and color pass vertex shader uniform buffer
Util.CheckResult(vulkanDevice.createBuffer(
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
uniformBuffers_scene,
(ulong)sizeof(UboVS)));
// Fullscreen radial blur parameters
var blurParamsLocal = uboBlurParams;
Util.CheckResult(vulkanDevice.createBuffer(
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
uniformBuffers_blurParams,
(ulong)sizeof(UboBlurParams),
&blurParamsLocal));
// Map persistent
Util.CheckResult(uniformBuffers_scene.map());
Util.CheckResult(uniformBuffers_blurParams.map());
updateUniformBuffersScene();
}
// Prepare and initialize uniform buffer containing shader uniforms
void prepareUniformBuffers()
{
// Allocate data for the dynamic uniform buffer object
// We allocate this manually as the alignment of the offset differs between GPUs
// Calculate required alignment depending on device limits
ulong uboAlignment = vulkanDevice.properties.limits.minUniformBufferOffsetAlignment;
dynamicAlignment = (IntPtr)(((ulong)sizeof(Matrix4x4) / uboAlignment) * uboAlignment + (((ulong)sizeof(Matrix4x4) % uboAlignment) > 0 ? uboAlignment : 0));
IntPtr bufferSize = (IntPtr)(OBJECT_INSTANCES * (ulong)dynamicAlignment);
uboDataDynamic_model = (Matrix4x4 *)alignedAlloc(bufferSize, dynamicAlignment);
Debug.Assert(uboDataDynamic_model != null);
Console.WriteLine("minUniformBufferOffsetAlignment = " + uboAlignment);
Console.WriteLine("dynamicAlignment = " + dynamicAlignment);
// Vertex shader uniform buffer block
// Static shared uniform buffer object with projection and view matrix
Util.CheckResult(vulkanDevice.createBuffer(
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
uniformBuffers_view,
(ulong)sizeof(UboVS)));
// Uniform buffer object with per-object matrices
Util.CheckResult(vulkanDevice.createBuffer(
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
uniformBuffers_dynamic,
(ulong)bufferSize));
// Map persistent
Util.CheckResult(uniformBuffers_view.map());
Util.CheckResult(uniformBuffers_dynamic.map());
// Prepare per-object matrices with offsets and random rotations
Random rndGen = new Random();
Func <Random, float> rndDist = rand => (float)(rand.NextDouble() * 2 - 1.0);
for (uint i = 0; i < OBJECT_INSTANCES; i++)
{
rotations[i] = new Vector3(rndDist(rndGen), rndDist(rndGen), rndDist(rndGen)) * 2.0f * (float)Math.PI;
rotationSpeeds[i] = new Vector3(rndDist(rndGen), rndDist(rndGen), rndDist(rndGen));
}
updateUniformBuffers();
updateDynamicUniformBuffer(true);
}
// Prepare and initialize uniform buffer containing shader uniforms
void prepareUniformBuffers()
{
// Vertex shader uniform buffer block
Util.CheckResult(vulkanDevice.createBuffer(
VkBufferUsageFlags.UniformBuffer,
VkMemoryPropertyFlags.HostVisible | VkMemoryPropertyFlags.HostCoherent,
uniformBuffers_scene,
(uint)sizeof(UboVS)));
// Map persistent
Util.CheckResult(uniformBuffers_scene.map());
updateUniformBuffers();
}
// Prepare and initialize uniform buffer containing shader uniforms
void prepareUniformBuffers()
{
// Create the vertex shader uniform buffer block
Util.CheckResult(vulkanDevice.createBuffer(
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
uniformBuffer,
(ulong)sizeof(UboVS)));
// Map persistent
Util.CheckResult(uniformBuffer.map());
updateUniformBuffers();
}
void updateUniformBuffers()
{
// Vertex shader
uboVS.projection = Matrix4x4.CreatePerspectiveFieldOfView(Util.DegreesToRadians(60f), width / (float)height, 0.1f, 256.0f);
Matrix4x4 viewMatrix = Matrix4x4.CreateTranslation(new Vector3(0f, 0f, zoom));
uboVS.model = viewMatrix * Matrix4x4.CreateTranslation(cameraPos);
uboVS.model = Matrix4x4.CreateRotationX(Util.DegreesToRadians(rotation.X)) * uboVS.model;
uboVS.model = Matrix4x4.CreateRotationY(Util.DegreesToRadians(rotation.Y)) * uboVS.model;
uboVS.model = Matrix4x4.CreateRotationZ(Util.DegreesToRadians(rotation.Z)) * uboVS.model;
uboVS.viewPos = new Vector4(0.0f, 0.0f, -zoom, 0.0f);
Util.CheckResult(uniformBufferVS.map());
var local = uboVS;
Unsafe.CopyBlock(uniformBufferVS.mapped, &local, (uint)sizeof(UboVS));
uniformBufferVS.unmap();
}
/**
* Create a buffer on the device
*
* @param usageFlags Usage flag bitmask for the buffer (i.e. index, vertex, uniform buffer)
* @param memoryPropertyFlags Memory properties for this buffer (i.e. device local, host visible, coherent)
* @param buffer Pointer to a vk::Vulkan buffer object
* @param size Size of the buffer in byes
* @param data Pointer to the data that should be copied to the buffer after creation (optional, if not set, no data is copied over)
*
* @return VK_SUCCESS if buffer handle and memory have been created and (optionally passed) data has been copied
*/
public VkResult createBuffer(VkBufferUsageFlags usageFlags, VkMemoryPropertyFlags memoryPropertyFlags, vksBuffer buffer, ulong size, void *data = null)
{
buffer.device = _logicalDevice;
// Create the buffer handle
VkBufferCreateInfo bufferCreateInfo = VkBufferCreateInfo.New();
bufferCreateInfo.usage = usageFlags;
bufferCreateInfo.size = size;
Util.CheckResult(vkCreateBuffer(_logicalDevice, &bufferCreateInfo, null, out buffer.buffer));
// Create the memory backing up the buffer handle
VkMemoryRequirements memReqs;
VkMemoryAllocateInfo memAlloc = VkMemoryAllocateInfo.New();
vkGetBufferMemoryRequirements(_logicalDevice, buffer.buffer, &memReqs);
memAlloc.allocationSize = memReqs.size;
// Find a memory type index that fits the properties of the buffer
memAlloc.memoryTypeIndex = GetMemoryType(memReqs.memoryTypeBits, memoryPropertyFlags);
Util.CheckResult(vkAllocateMemory(_logicalDevice, &memAlloc, null, out buffer.memory));
buffer.alignment = memReqs.alignment;
buffer.size = memAlloc.allocationSize;
buffer.usageFlags = usageFlags;
buffer.memoryPropertyFlags = memoryPropertyFlags;
// If a pointer to the buffer data has been passed, map the buffer and copy over the data
if (data != null)
{
Util.CheckResult(buffer.map());
Unsafe.CopyBlock(buffer.mapped, data, (uint)size);
buffer.unmap();
}
// Initialize a default descriptor that covers the whole buffer size
buffer.setupDescriptor();
// Attach the memory to the buffer object
return(buffer.bind());
}
// Prepare and initialize uniform buffer containing shader uniforms
void prepareUniformBuffers()
{
// Objact vertex shader uniform buffer
Util.CheckResult(vulkanDevice.createBuffer(
VkBufferUsageFlags.UniformBuffer,
VkMemoryPropertyFlags.HostVisible | VkMemoryPropertyFlags.HostCoherent,
uniformBuffers_object,
(ulong)sizeof(UboVS)));
// Skybox vertex shader uniform buffer
Util.CheckResult(vulkanDevice.createBuffer(
VkBufferUsageFlags.UniformBuffer,
VkMemoryPropertyFlags.HostVisible | VkMemoryPropertyFlags.HostCoherent,
uniformBuffers_skybox,
(uint)sizeof(UboVS)));
// Map persistent
Util.CheckResult(uniformBuffers_object.map());
Util.CheckResult(uniformBuffers_skybox.map());
updateUniformBuffers();
}
// Prepare and initialize uniform buffer containing shader uniforms
void prepareUniformBuffers()
{
// Mesh vertex shader uniform buffer block
Util.CheckResult(vulkanDevice.createBuffer(
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
uniformBuffers_vsShared,
(ulong)sizeof(UBO)));
// Mirror plane vertex shader uniform buffer block
Util.CheckResult(vulkanDevice.createBuffer(
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
uniformBuffers_vsMirror,
(ulong)sizeof(UBO)));
// Offscreen vertex shader uniform buffer block
Util.CheckResult(vulkanDevice.createBuffer(
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
uniformBuffers_vsOffScreen,
(ulong)sizeof(UBO)));
// Debug quad vertex shader uniform buffer block
Util.CheckResult(vulkanDevice.createBuffer(
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
uniformBuffers_vsDebugQuad,
(ulong)sizeof(UBO)));
// Map persistent
Util.CheckResult(uniformBuffers_vsShared.map());
Util.CheckResult(uniformBuffers_vsMirror.map());
Util.CheckResult(uniformBuffers_vsOffScreen.map());
Util.CheckResult(uniformBuffers_vsDebugQuad.map());
updateUniformBuffers();
updateUniformBufferOffscreen();
}
