void setupDescriptorSet()
{
var dsl = descriptorSetLayout;
VkDescriptorSetAllocateInfo allocInfo =
Initializers.descriptorSetAllocateInfo(
descriptorPool,
&dsl,
1);
Util.CheckResult(vkAllocateDescriptorSets(device, &allocInfo, out descriptorSet));
VkDescriptorImageInfo texDescriptor =
Initializers.descriptorImageInfo(
textures_colorMap.sampler,
textures_colorMap.view,
VkImageLayout.General);
var temp = uniformBuffers_scene.descriptor;
FixedArray2 <VkWriteDescriptorSet> writeDescriptorSets = new FixedArray2 <VkWriteDescriptorSet>(
// Binding 0 : Vertex shader uniform buffer
Initializers.writeDescriptorSet(
descriptorSet,
VkDescriptorType.UniformBuffer,
0,
&temp),
// Binding 1 : Color map
Initializers.writeDescriptorSet(
descriptorSet,
VkDescriptorType.CombinedImageSampler,
1,
&texDescriptor));
vkUpdateDescriptorSets(device, (writeDescriptorSets.Count), ref writeDescriptorSets.First, 0, null);
}
void setupDescriptorSetLayout()
{
FixedArray2<VkDescriptorSetLayoutBinding> setLayoutBindings = new FixedArray2<VkDescriptorSetLayoutBinding>(
// Binding 0 : Vertex shader uniform buffer
Initializers.descriptorSetLayoutBinding(
VkDescriptorType.UniformBuffer,
VkShaderStageFlags.Vertex,
0),
// Binding 1 : Fragment shader image sampler
Initializers.descriptorSetLayoutBinding(
VkDescriptorType.CombinedImageSampler,
VkShaderStageFlags.Fragment,
1));
VkDescriptorSetLayoutCreateInfo descriptorLayout =
Initializers.descriptorSetLayoutCreateInfo(
&setLayoutBindings.First,
setLayoutBindings.Count);
Util.CheckResult(vkCreateDescriptorSetLayout(device, &descriptorLayout, null, out descriptorSetLayout));
var dsl = descriptorSetLayout;
VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =
Initializers.pipelineLayoutCreateInfo(
&dsl,
1);
Util.CheckResult(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, null, out pipelineLayout));
}
protected override void buildCommandBuffers()
{
VkCommandBufferBeginInfo cmdBufInfo = Initializers.commandBufferBeginInfo();
FixedArray2 <VkClearValue> clearValues = new FixedArray2 <VkClearValue>();
clearValues.First.color = defaultClearColor;
clearValues.Second.depthStencil = new VkClearDepthStencilValue {
depth = 1.0f, stencil = 0
};
VkRenderPassBeginInfo renderPassBeginInfo = Initializers.renderPassBeginInfo();
renderPassBeginInfo.renderPass = renderPass;
renderPassBeginInfo.renderArea.offset.x = 0;
renderPassBeginInfo.renderArea.offset.y = 0;
renderPassBeginInfo.renderArea.extent.width = width;
renderPassBeginInfo.renderArea.extent.height = height;
renderPassBeginInfo.clearValueCount = 2;
renderPassBeginInfo.pClearValues = &clearValues.First;
for (int i = 0; i < drawCmdBuffers.Count; ++i)
{
// Set target frame buffer
renderPassBeginInfo.framebuffer = frameBuffers[i];
Util.CheckResult(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));
vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
VkViewport viewport = Initializers.viewport((float)width, (float)height, 0.0f, 1.0f);
vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
VkRect2D scissor = Initializers.rect2D(width, height, 0, 0);
vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);
ulong offsets = 0;
// 3D scene
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts_scene, 0, 1, ref descriptorSets_scene, 0, null);
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines_phongPass);
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, ref models_example.vertices.buffer, &offsets);
vkCmdBindIndexBuffer(drawCmdBuffers[i], models_example.indices.buffer, 0, VK_INDEX_TYPE_UINT32);
vkCmdDrawIndexed(drawCmdBuffers[i], models_example.indexCount, 1, 0, 0, 0);
// Fullscreen triangle (clipped to a quad) with radial blur
if (blur)
{
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts_radialBlur, 0, 1, ref descriptorSets_radialBlur, 0, null);
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, (displayTexture) ? pipelines_offscreenDisplay : pipelines_radialBlur);
vkCmdDraw(drawCmdBuffers[i], 3, 1, 0, 0);
}
vkCmdEndRenderPass(drawCmdBuffers[i]);
Util.CheckResult(vkEndCommandBuffer(drawCmdBuffers[i]));
}
}
void setupDescriptorSets()
{
// Image descriptor for the cube map texture
VkDescriptorImageInfo textureDescriptor =
Initializers.descriptorImageInfo(
cubeMap.sampler,
cubeMap.view,
cubeMap.imageLayout);
var dsl = descriptorSetLayout;
VkDescriptorSetAllocateInfo allocInfo =
Initializers.descriptorSetAllocateInfo(
descriptorPool,
&dsl,
1);
// 3D object descriptor set
Util.CheckResult(vkAllocateDescriptorSets(device, &allocInfo, out descriptorSets_object));
var bufferInfo = uniformBuffers_object.descriptor;
FixedArray2 <VkWriteDescriptorSet> writeDescriptorSets = new FixedArray2 <VkWriteDescriptorSet>
(
// Binding 0 : Vertex shader uniform buffer
Initializers.writeDescriptorSet(
descriptorSets_object,
VkDescriptorType.UniformBuffer,
0,
&bufferInfo),
// Binding 1 : Fragment shader cubemap sampler
Initializers.writeDescriptorSet(
descriptorSets_object,
VkDescriptorType.CombinedImageSampler,
1,
&textureDescriptor));
vkUpdateDescriptorSets(device, writeDescriptorSets.Count, ref writeDescriptorSets.First, 0, null);
// Sky box descriptor set
Util.CheckResult(vkAllocateDescriptorSets(device, &allocInfo, out descriptorSets_skybox));
var descriptor = uniformBuffers_skybox.descriptor;
writeDescriptorSets = new FixedArray2 <VkWriteDescriptorSet>
(
// Binding 0 : Vertex shader uniform buffer
Initializers.writeDescriptorSet(
descriptorSets_skybox,
VkDescriptorType.UniformBuffer,
0,
&descriptor),
// Binding 1 : Fragment shader cubemap sampler
Initializers.writeDescriptorSet(
descriptorSets_skybox,
VkDescriptorType.CombinedImageSampler,
1,
&textureDescriptor));
vkUpdateDescriptorSets(device, writeDescriptorSets.Count, ref writeDescriptorSets.First, 0, null);
}
// Sets up the command buffer that renders the scene to the offscreen frame buffer
void buildOffscreenCommandBuffer()
{
if (offscreenPass.commandBuffer == NullHandle)
{
offscreenPass.commandBuffer = createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, false);
}
if (offscreenPass.semaphore == NullHandle)
{
VkSemaphoreCreateInfo semaphoreCreateInfo = Initializers.semaphoreCreateInfo();
Util.CheckResult(vkCreateSemaphore(device, &semaphoreCreateInfo, null, out offscreenPass.semaphore));
}
VkCommandBufferBeginInfo cmdBufInfo = Initializers.commandBufferBeginInfo();
FixedArray2 <VkClearValue> clearValues = new FixedArray2 <VkClearValue>();
clearValues.First.color = new VkClearColorValue {
float32_0 = 0.0f, float32_1 = 0.0f, float32_2 = 0.0f, float32_3 = 0.0f
};
clearValues.Second.depthStencil = new VkClearDepthStencilValue {
depth = 1.0f, stencil = 0
};
VkRenderPassBeginInfo renderPassBeginInfo = Initializers.renderPassBeginInfo();
renderPassBeginInfo.renderPass = offscreenPass.renderPass;
renderPassBeginInfo.framebuffer = offscreenPass.frameBuffer;
renderPassBeginInfo.renderArea.extent.width = offscreenPass.width;
renderPassBeginInfo.renderArea.extent.height = offscreenPass.height;
renderPassBeginInfo.clearValueCount = 2;
renderPassBeginInfo.pClearValues = &clearValues.First;
Util.CheckResult(vkBeginCommandBuffer(offscreenPass.commandBuffer, &cmdBufInfo));
VkViewport viewport = Initializers.viewport((float)offscreenPass.width, (float)offscreenPass.height, 0.0f, 1.0f);
vkCmdSetViewport(offscreenPass.commandBuffer, 0, 1, &viewport);
VkRect2D scissor = Initializers.rect2D(offscreenPass.width, offscreenPass.height, 0, 0);
vkCmdSetScissor(offscreenPass.commandBuffer, 0, 1, &scissor);
vkCmdBeginRenderPass(offscreenPass.commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindDescriptorSets(offscreenPass.commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts_scene, 0, 1, ref descriptorSets_scene, 0, null);
vkCmdBindPipeline(offscreenPass.commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines_colorPass);
ulong offsets = 0;
vkCmdBindVertexBuffers(offscreenPass.commandBuffer, VERTEX_BUFFER_BIND_ID, 1, ref models_example.vertices.buffer, &offsets);
vkCmdBindIndexBuffer(offscreenPass.commandBuffer, models_example.indices.buffer, 0, VK_INDEX_TYPE_UINT32);
vkCmdDrawIndexed(offscreenPass.commandBuffer, models_example.indexCount, 1, 0, 0, 0);
vkCmdEndRenderPass(offscreenPass.commandBuffer);
Util.CheckResult(vkEndCommandBuffer(offscreenPass.commandBuffer));
}
protected override void buildCommandBuffers()
{
VkCommandBufferBeginInfo cmdBufInfo = Initializers.commandBufferBeginInfo();
FixedArray2 <VkClearValue> clearValues = new FixedArray2 <VkClearValue>();
clearValues.First.color = defaultClearColor;
clearValues.Second.depthStencil = new VkClearDepthStencilValue {
depth = 1.0f, stencil = 0
};
VkRenderPassBeginInfo renderPassBeginInfo = Initializers.renderPassBeginInfo();
renderPassBeginInfo.renderPass = renderPass;
renderPassBeginInfo.renderArea.offset.x = 0;
renderPassBeginInfo.renderArea.offset.y = 0;
renderPassBeginInfo.renderArea.extent.width = width;
renderPassBeginInfo.renderArea.extent.height = height;
renderPassBeginInfo.clearValueCount = 2;
renderPassBeginInfo.pClearValues = &clearValues.First;
for (int i = 0; i < drawCmdBuffers.Count; ++i)
{
renderPassBeginInfo.framebuffer = frameBuffers[i];
Util.CheckResult(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));
vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
VkViewport viewport = Initializers.viewport((float)width, (float)height, 0.0f, 1.0f);
vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
VkRect2D scissor = Initializers.rect2D(width, height, 0, 0);
vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
ulong offsets = 0;
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, ref vertexBuffer.buffer, &offsets);
vkCmdBindIndexBuffer(drawCmdBuffers[i], indexBuffer.buffer, 0, VK_INDEX_TYPE_UINT32);
// Render multiple objects using different model matrices by dynamically offsetting into one uniform buffer
for (uint j = 0; j < OBJECT_INSTANCES; j++)
{
// One dynamic offset per dynamic descriptor to offset into the ubo containing all model matrices
uint dynamicOffset = j * (uint)(dynamicAlignment);
// Bind the descriptor set for rendering a mesh using the dynamic offset
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, ref descriptorSet, 1, &dynamicOffset);
vkCmdDrawIndexed(drawCmdBuffers[i], indexCount, 1, 0, 0, 0);
}
vkCmdEndRenderPass(drawCmdBuffers[i]);
Util.CheckResult(vkEndCommandBuffer(drawCmdBuffers[i]));
}
}
protected override void buildCommandBuffers()
{
VkCommandBufferBeginInfo cmdBufInfo = Initializers.commandBufferBeginInfo();
FixedArray2<VkClearValue> clearValues = new FixedArray2<VkClearValue>();
clearValues.First.color = defaultClearColor;
clearValues.Second.depthStencil = new VkClearDepthStencilValue { depth = 1.0f, stencil = 0 };
VkRenderPassBeginInfo renderPassBeginInfo = Initializers.renderPassBeginInfo();
renderPassBeginInfo.renderPass = renderPass;
renderPassBeginInfo.renderArea.offset.x = 0;
renderPassBeginInfo.renderArea.offset.y = 0;
renderPassBeginInfo.renderArea.extent.width = width;
renderPassBeginInfo.renderArea.extent.height = height;
renderPassBeginInfo.clearValueCount = 2;
renderPassBeginInfo.pClearValues = &clearValues.First;
for (int i = 0; i < drawCmdBuffers.Count; ++i)
{
// Set target frame buffer
renderPassBeginInfo.framebuffer = frameBuffers[i];
Util.CheckResult(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));
vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VkSubpassContents.Inline);
VkViewport viewport = Initializers.viewport((float)width, (float)height, 0.0f, 1.0f);
vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
VkRect2D scissor = Initializers.rect2D(width, height, 0, 0);
vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);
ulong offsets = 0;
// Skybox
if (displaySkybox)
{
vkCmdBindDescriptorSets(drawCmdBuffers[i], VkPipelineBindPoint.Graphics, pipelineLayout, 0, 1, ref descriptorSets_skybox, 0, null);
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, ref models_skybox.vertices.buffer, ref offsets);
vkCmdBindIndexBuffer(drawCmdBuffers[i], models_skybox.indices.buffer, 0, VkIndexType.Uint32);
vkCmdBindPipeline(drawCmdBuffers[i], VkPipelineBindPoint.Graphics, pipelines_skybox);
vkCmdDrawIndexed(drawCmdBuffers[i], models_skybox.indexCount, 1, 0, 0, 0);
}
// 3D object
vkCmdBindDescriptorSets(drawCmdBuffers[i], VkPipelineBindPoint.Graphics, pipelineLayout, 0, 1, ref descriptorSets_object, 0, null);
var vbuffer = models_objects[(int)models_objectIndex].vertices.buffer;
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &vbuffer, ref offsets);
vkCmdBindIndexBuffer(drawCmdBuffers[i], models_objects[(int)models_objectIndex].indices.buffer, 0, VkIndexType.Uint32);
vkCmdBindPipeline(drawCmdBuffers[i], VkPipelineBindPoint.Graphics, pipelines_reflect);
vkCmdDrawIndexed(drawCmdBuffers[i], models_objects[(int)models_objectIndex].indexCount, 1, 0, 0, 0);
vkCmdEndRenderPass(drawCmdBuffers[i]);
Util.CheckResult(vkEndCommandBuffer(drawCmdBuffers[i]));
}
}
protected override void buildCommandBuffers()
{
VkCommandBufferBeginInfo cmdBufInfo = Initializers.CommandBufferBeginInfo();
FixedArray2 <VkClearValue> clearValues = new FixedArray2 <VkClearValue>();
clearValues.First.color = defaultClearColor;
clearValues.Second.depthStencil = new VkClearDepthStencilValue()
{
depth = 1.0f, stencil = 0
};
VkRenderPassBeginInfo renderPassBeginInfo = Initializers.renderPassBeginInfo();
renderPassBeginInfo.renderPass = RenderPass;
renderPassBeginInfo.renderArea.offset.x = 0;
renderPassBeginInfo.renderArea.offset.y = 0;
renderPassBeginInfo.renderArea.extent.width = Width;
renderPassBeginInfo.renderArea.extent.height = Height;
renderPassBeginInfo.clearValueCount = 2;
renderPassBeginInfo.pClearValues = &clearValues.First;
for (int i = 0; i < DrawCmdBuffers.Count; ++i)
{
// Set target frame buffer
renderPassBeginInfo.framebuffer = Framebuffers[i];
Util.CheckResult(vkBeginCommandBuffer(DrawCmdBuffers[i], &cmdBufInfo));
vkCmdBeginRenderPass(DrawCmdBuffers[i], &renderPassBeginInfo, VkSubpassContents.Inline);
VkViewport viewport = Initializers.viewport((float)Width, (float)Height, 0.0f, 1.0f);
vkCmdSetViewport(DrawCmdBuffers[i], 0, 1, &viewport);
VkRect2D scissor = Initializers.rect2D(Width, Height, 0, 0);
vkCmdSetScissor(DrawCmdBuffers[i], 0, 1, &scissor);
vkCmdBindDescriptorSets(DrawCmdBuffers[i], VkPipelineBindPoint.Graphics, pipelineLayout, 0, 1, ref descriptorSet, 0, null);
vkCmdBindPipeline(DrawCmdBuffers[i], VkPipelineBindPoint.Graphics, wireframe ? pipelines_wireframe : pipelines_solid);
ulong offsets = 0;
// Bind mesh vertex buffer
vkCmdBindVertexBuffers(DrawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, ref model_vertices_buffer, ref offsets);
// Bind mesh index buffer
vkCmdBindIndexBuffer(DrawCmdBuffers[i], model_indices_buffer, 0, VkIndexType.Uint32);
// Render mesh vertex buffer using it's indices
vkCmdDrawIndexed(DrawCmdBuffers[i], (uint)model_indices_count, 1, 0, 0, 0);
vkCmdEndRenderPass(DrawCmdBuffers[i]);
Util.CheckResult(vkEndCommandBuffer(DrawCmdBuffers[i]));
}
}
void setupDescriptorPool()
{
FixedArray2 <VkDescriptorPoolSize> poolSizes = new FixedArray2 <VkDescriptorPoolSize>(
Initializers.descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1),
Initializers.descriptorPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1));
VkDescriptorPoolCreateInfo descriptorPoolInfo =
Initializers.descriptorPoolCreateInfo(
(uint)(poolSizes.Count),
&poolSizes.First,
1);
Util.CheckResult(vkCreateDescriptorPool(device, &descriptorPoolInfo, null, out descriptorPool));
}
void setupDescriptorPool()
{
FixedArray2<VkDescriptorPoolSize> poolSizes = new FixedArray2<VkDescriptorPoolSize>(
Initializers.descriptorPoolSize(VkDescriptorType.UniformBuffer, 2),
Initializers.descriptorPoolSize(VkDescriptorType.CombinedImageSampler, 2));
VkDescriptorPoolCreateInfo descriptorPoolInfo =
Initializers.descriptorPoolCreateInfo(
poolSizes.Count,
&poolSizes.First,
2);
Util.CheckResult(vkCreateDescriptorPool(device, &descriptorPoolInfo, null, out descriptorPool));
}
void setupDescriptorPool()
{
// Example uses one ubo and one combined image sampler
FixedArray2 <VkDescriptorPoolSize> poolSizes = new FixedArray2 <VkDescriptorPoolSize>(
Initializers.descriptorPoolSize(VkDescriptorType.UniformBuffer, 1),
Initializers.descriptorPoolSize(VkDescriptorType.CombinedImageSampler, 1));
VkDescriptorPoolCreateInfo descriptorPoolInfo =
Initializers.descriptorPoolCreateInfo(
poolSizes.Count,
&poolSizes.First,
1);
Util.CheckResult(vkCreateDescriptorPool(Device, &descriptorPoolInfo, null, out descriptorPool));
}
void setupDescriptorPool()
{
// Example uses one ubo and one image sampler
FixedArray2 <VkDescriptorPoolSize> poolSizes = new FixedArray2 <VkDescriptorPoolSize>(
Initializers.descriptorPoolSize(VkDescriptorType.UniformBuffer, 1),
Initializers.descriptorPoolSize(VkDescriptorType.CombinedImageSampler, 1)
);
VkDescriptorPoolCreateInfo descriptorPoolInfo =
Initializers.descriptorPoolCreateInfo(
poolSizes.Count,
(VkDescriptorPoolSize *)Unsafe.AsPointer(ref poolSizes),
2);
Util.CheckResult(vkCreateDescriptorPool(device, &descriptorPoolInfo, null, out descriptorPool));
}
void setupDescriptorSet()
{
var dsl = descriptorSetLayout;
VkDescriptorSetAllocateInfo allocInfo =
Initializers.descriptorSetAllocateInfo(
descriptorPool,
&dsl,
1);
Util.CheckResult(vkAllocateDescriptorSets(device, &allocInfo, out descriptorSet));
var descriptor1 = uniformBuffer.descriptor;
var descriptor2 = textures_colormap.descriptor;
FixedArray2 <VkWriteDescriptorSet> writeDescriptorSets = new FixedArray2 <VkWriteDescriptorSet>(
Initializers.writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &descriptor1),
Initializers.writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, &descriptor2));
vkUpdateDescriptorSets(device, (uint)(writeDescriptorSets.Count), &writeDescriptorSets.First, 0, null);
}
void setupDescriptorSetLayout()
{
FixedArray2 <VkDescriptorSetLayoutBinding> setLayoutBindings = new FixedArray2 <VkDescriptorSetLayoutBinding>(
Initializers.descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT, 0),
Initializers.descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, 1));
VkDescriptorSetLayoutCreateInfo descriptorLayout =
Initializers.descriptorSetLayoutCreateInfo(
&setLayoutBindings.First,
setLayoutBindings.Count);
Util.CheckResult(vkCreateDescriptorSetLayout(device, &descriptorLayout, null, out descriptorSetLayout));
var dsl = descriptorSetLayout;
VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =
Initializers.pipelineLayoutCreateInfo(
&dsl,
1);
Util.CheckResult(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, null, out pipelineLayout));
}
void setupDescriptorSet()
{
var dsl = descriptorSetLayout;
VkDescriptorSetAllocateInfo allocInfo =
Initializers.descriptorSetAllocateInfo(
descriptorPool,
&dsl,
1);
Util.CheckResult(vkAllocateDescriptorSets(device, &allocInfo, out descriptorSet));
var descriptor0 = uniformBuffers_view.descriptor;
var descriptor1 = uniformBuffers_dynamic.descriptor;
FixedArray2 <VkWriteDescriptorSet> writeDescriptorSets = new FixedArray2 <VkWriteDescriptorSet>(
// Binding 0 : Projection/View matrix uniform buffer
Initializers.writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &descriptor0),
// Binding 1 : Instance matrix as dynamic uniform buffer
Initializers.writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, &descriptor1));
vkUpdateDescriptorSets(device, writeDescriptorSets.Count, &writeDescriptorSets.First, 0, null);
}
void setupDescriptorSet()
{
var layout = descriptorSetLayout;
VkDescriptorSetAllocateInfo allocInfo =
Initializers.descriptorSetAllocateInfo(
descriptorPool,
&layout,
1);
Util.CheckResult(vkAllocateDescriptorSets(device, &allocInfo, out descriptorSet));
// Setup a descriptor image info for the current texture to be used as a combined image sampler
VkDescriptorImageInfo textureDescriptor;
textureDescriptor.imageView = texture.view; // The image's view (images are never directly accessed by the shader, but rather through views defining subresources)
textureDescriptor.sampler = texture.sampler; // The sampler (Telling the pipeline how to sample the texture, including repeat, border, etc.)
textureDescriptor.imageLayout = texture.imageLayout; // The current layout of the image (Note: Should always fit the actual use, e.g. shader read)
var descriptor = uniformBufferVS.descriptor;
FixedArray2 <VkWriteDescriptorSet> writeDescriptorSets = new FixedArray2 <VkWriteDescriptorSet>(
// Binding 0 : Vertex shader uniform buffer
Initializers.writeDescriptorSet(
descriptorSet,
VkDescriptorType.UniformBuffer,
0,
&descriptor),
// Binding 1 : Fragment shader texture sampler
// Fragment shader: layout (binding = 1) uniform sampler2D samplerColor;
Initializers.writeDescriptorSet(
descriptorSet,
VkDescriptorType.CombinedImageSampler, // The descriptor set will use a combined image sampler (sampler and image could be split)
1, // Shader binding point 1
&textureDescriptor) // Pointer to the descriptor image for our texture
);
vkUpdateDescriptorSets(device, writeDescriptorSets.Count, ref writeDescriptorSets.First, 0, null);
}
void preparePipelines()
{
VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
Initializers.pipelineInputAssemblyStateCreateInfo(
VkPrimitiveTopology.TriangleList,
0,
False);
VkPipelineRasterizationStateCreateInfo rasterizationState =
Initializers.pipelineRasterizationStateCreateInfo(
VkPolygonMode.Fill,
VkCullModeFlags.Back,
VkFrontFace.Clockwise,
0);
VkPipelineColorBlendAttachmentState blendAttachmentState =
Initializers.pipelineColorBlendAttachmentState(
0xf,
False);
VkPipelineColorBlendStateCreateInfo colorBlendState =
Initializers.pipelineColorBlendStateCreateInfo(
1,
&blendAttachmentState);
VkPipelineDepthStencilStateCreateInfo depthStencilState =
Initializers.pipelineDepthStencilStateCreateInfo(
True,
True,
VkCompareOp.LessOrEqual);
VkPipelineViewportStateCreateInfo viewportState =
Initializers.pipelineViewportStateCreateInfo(1, 1, 0);
VkPipelineMultisampleStateCreateInfo multisampleState =
Initializers.pipelineMultisampleStateCreateInfo(
VkSampleCountFlags.Count1,
0);
FixedArray2 <VkDynamicState> dynamicStateEnables = new FixedArray2 <VkDynamicState>(
VkDynamicState.Viewport,
VkDynamicState.Scissor);
VkPipelineDynamicStateCreateInfo dynamicState =
Initializers.pipelineDynamicStateCreateInfo(
&dynamicStateEnables.First,
dynamicStateEnables.Count,
0);
// Solid rendering pipeline
// Load shaders
FixedArray2 <VkPipelineShaderStageCreateInfo> shaderStages = new FixedArray2 <VkPipelineShaderStageCreateInfo>(
loadShader(getAssetPath() + "shaders/mesh/mesh.vert.spv", VkShaderStageFlags.Vertex),
loadShader(getAssetPath() + "shaders/mesh/mesh.frag.spv", VkShaderStageFlags.Fragment));
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
Initializers.pipelineCreateInfo(
pipelineLayout,
renderPass,
0);
var via = vertices_inputState;
pipelineCreateInfo.pVertexInputState = &via;
pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState;
pipelineCreateInfo.pRasterizationState = &rasterizationState;
pipelineCreateInfo.pColorBlendState = &colorBlendState;
pipelineCreateInfo.pMultisampleState = &multisampleState;
pipelineCreateInfo.pViewportState = &viewportState;
pipelineCreateInfo.pDepthStencilState = &depthStencilState;
pipelineCreateInfo.pDynamicState = &dynamicState;
pipelineCreateInfo.stageCount = shaderStages.Count;
pipelineCreateInfo.pStages = &shaderStages.First;
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipelines_solid));
// Wire frame rendering pipeline
if (DeviceFeatures.fillModeNonSolid == 1)
{
rasterizationState.polygonMode = VkPolygonMode.Line;
rasterizationState.lineWidth = 1.0f;
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipelines_wireframe));
}
}
void setupDescriptorSet()
{
var dsl = descriptorSetLayouts_textured;
// Mirror plane descriptor set
VkDescriptorSetAllocateInfo allocInfo =
Initializers.descriptorSetAllocateInfo(
descriptorPool,
&dsl,
1);
Util.CheckResult(vkAllocateDescriptorSets(device, &allocInfo, out descriptorSets_mirror));
var descriptor0 = uniformBuffers_vsMirror.descriptor;
var descriptor1 = offscreenPass.descriptor;
var descriptor2 = textures_colorMap.descriptor;
FixedArray3<VkWriteDescriptorSet> writeDescriptorSets = new FixedArray3<VkWriteDescriptorSet>(
// Binding 0 : Vertex shader uniform buffer
Initializers.writeDescriptorSet(
descriptorSets_mirror,
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
0,
&descriptor0),
// Binding 1 : Fragment shader texture sampler
Initializers.writeDescriptorSet(
descriptorSets_mirror,
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
1,
&descriptor1),
// Binding 2 : Fragment shader texture sampler
Initializers.writeDescriptorSet(
descriptorSets_mirror,
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
2,
&descriptor2));
vkUpdateDescriptorSets(device, writeDescriptorSets.Count, &writeDescriptorSets.First, 0, null);
// Debug quad
Util.CheckResult(vkAllocateDescriptorSets(device, &allocInfo, out descriptorSets_debugQuad));
var descriptor3 = uniformBuffers_vsDebugQuad.descriptor;
var descriptor4 = offscreenPass.descriptor;
FixedArray2<VkWriteDescriptorSet> debugQuadWriteDescriptorSets = new FixedArray2<VkWriteDescriptorSet>(
// Binding 0 : Vertex shader uniform buffer
Initializers.writeDescriptorSet(
descriptorSets_debugQuad,
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
0,
&descriptor3),
// Binding 1 : Fragment shader texture sampler
Initializers.writeDescriptorSet(
descriptorSets_debugQuad,
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
1,
&descriptor4));
vkUpdateDescriptorSets(device, debugQuadWriteDescriptorSets.Count, &debugQuadWriteDescriptorSets.First, 0, null);
var dsls_shaded = descriptorSetLayouts_shaded;
// Shaded descriptor sets
allocInfo.pSetLayouts = &dsls_shaded;
// Model
// No texture
Util.CheckResult(vkAllocateDescriptorSets(device, &allocInfo, out descriptorSets_model));
var descriptor5 = uniformBuffers_vsShared.descriptor;
VkWriteDescriptorSet modelWriteDescriptorSets =
// Binding 0 : Vertex shader uniform buffer
Initializers.writeDescriptorSet(
descriptorSets_model,
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
0,
&descriptor5);
vkUpdateDescriptorSets(device, 1, &modelWriteDescriptorSets, 0, null);
// Offscreen
Util.CheckResult(vkAllocateDescriptorSets(device, &allocInfo, out descriptorSets_offscreen));
var descriptor6 = uniformBuffers_vsOffScreen.descriptor;
VkWriteDescriptorSet offScreenWriteDescriptorSets =
// Binding 0 : Vertex shader uniform buffer
Initializers.writeDescriptorSet(
descriptorSets_offscreen,
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
0,
&descriptor6);
vkUpdateDescriptorSets(device, 1, &offScreenWriteDescriptorSets, 0, null);
}
void preparePipelines()
{
VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
Initializers.pipelineInputAssemblyStateCreateInfo(
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
0,
VK_FALSE);
VkPipelineRasterizationStateCreateInfo rasterizationState =
Initializers.pipelineRasterizationStateCreateInfo(
VK_POLYGON_MODE_FILL,
VK_CULL_MODE_NONE,
VK_FRONT_FACE_COUNTER_CLOCKWISE,
0);
VkPipelineColorBlendAttachmentState blendAttachmentState =
Initializers.pipelineColorBlendAttachmentState(
0xf,
VK_FALSE);
VkPipelineColorBlendStateCreateInfo colorBlendState =
Initializers.pipelineColorBlendStateCreateInfo(
1,
&blendAttachmentState);
VkPipelineDepthStencilStateCreateInfo depthStencilState =
Initializers.pipelineDepthStencilStateCreateInfo(
VK_TRUE,
VK_TRUE,
VK_COMPARE_OP_LESS_OR_EQUAL);
VkPipelineViewportStateCreateInfo viewportState =
Initializers.pipelineViewportStateCreateInfo(1, 1, 0);
VkPipelineMultisampleStateCreateInfo multisampleState =
Initializers.pipelineMultisampleStateCreateInfo(
VK_SAMPLE_COUNT_1_BIT,
0);
NativeList <VkDynamicState> dynamicStateEnables = new NativeList <VkDynamicState>
{
VK_DYNAMIC_STATE_VIEWPORT,
VK_DYNAMIC_STATE_SCISSOR
};
VkPipelineDynamicStateCreateInfo dynamicState =
Initializers.pipelineDynamicStateCreateInfo(
(VkDynamicState *)dynamicStateEnables.Data,
dynamicStateEnables.Count,
0);
FixedArray2 <VkPipelineShaderStageCreateInfo> shaderStages = new FixedArray2 <VkPipelineShaderStageCreateInfo>();
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
Initializers.pipelineCreateInfo(
pipelineLayouts_radialBlur,
renderPass,
0);
pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState;
pipelineCreateInfo.pRasterizationState = &rasterizationState;
pipelineCreateInfo.pColorBlendState = &colorBlendState;
pipelineCreateInfo.pMultisampleState = &multisampleState;
pipelineCreateInfo.pViewportState = &viewportState;
pipelineCreateInfo.pDepthStencilState = &depthStencilState;
pipelineCreateInfo.pDynamicState = &dynamicState;
pipelineCreateInfo.stageCount = shaderStages.Count;
pipelineCreateInfo.pStages = &shaderStages.First;
// Radial blur pipeline
shaderStages.First = loadShader(getAssetPath() + "shaders/radialblur/radialblur.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages.Second = loadShader(getAssetPath() + "shaders/radialblur/radialblur.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
// Empty vertex input state
VkPipelineVertexInputStateCreateInfo emptyInputState = Initializers.pipelineVertexInputStateCreateInfo();
pipelineCreateInfo.pVertexInputState = &emptyInputState;
pipelineCreateInfo.layout = pipelineLayouts_radialBlur;
// Additive blending
blendAttachmentState.colorWriteMask = (VkColorComponentFlags)0xF;
blendAttachmentState.blendEnable = VK_TRUE;
blendAttachmentState.colorBlendOp = VK_BLEND_OP_ADD;
blendAttachmentState.srcColorBlendFactor = VK_BLEND_FACTOR_ONE;
blendAttachmentState.dstColorBlendFactor = VK_BLEND_FACTOR_ONE;
blendAttachmentState.alphaBlendOp = VK_BLEND_OP_ADD;
blendAttachmentState.srcAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
blendAttachmentState.dstAlphaBlendFactor = VK_BLEND_FACTOR_DST_ALPHA;
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipelines_radialBlur));
// No blending (for debug display)
blendAttachmentState.blendEnable = VK_FALSE;
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipelines_offscreenDisplay));
// Phong pass
pipelineCreateInfo.layout = pipelineLayouts_scene;
shaderStages.First = loadShader(getAssetPath() + "shaders/radialblur/phongpass.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages.Second = loadShader(getAssetPath() + "shaders/radialblur/phongpass.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
var vis = vertices_inputState;
pipelineCreateInfo.pVertexInputState = &vis;
blendAttachmentState.blendEnable = VK_FALSE;
depthStencilState.depthWriteEnable = VK_TRUE;
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipelines_phongPass));
// Color only pass (offscreen blur base)
shaderStages.First = loadShader(getAssetPath() + "shaders/radialblur/colorpass.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages.Second = loadShader(getAssetPath() + "shaders/radialblur/colorpass.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
pipelineCreateInfo.renderPass = offscreenPass.renderPass;
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipelines_colorPass));
}
void preparePipelines()
{
VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
Initializers.pipelineInputAssemblyStateCreateInfo(
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
0,
VK_FALSE);
VkPipelineRasterizationStateCreateInfo rasterizationState =
Initializers.pipelineRasterizationStateCreateInfo(
VK_POLYGON_MODE_FILL,
VK_CULL_MODE_FRONT_BIT,
VK_FRONT_FACE_CLOCKWISE,
0);
VkPipelineColorBlendAttachmentState blendAttachmentState =
Initializers.pipelineColorBlendAttachmentState(
0xf,
VK_FALSE);
VkPipelineColorBlendStateCreateInfo colorBlendState =
Initializers.pipelineColorBlendStateCreateInfo(
1,
&blendAttachmentState);
VkPipelineDepthStencilStateCreateInfo depthStencilState =
Initializers.pipelineDepthStencilStateCreateInfo(
VK_TRUE,
VK_TRUE,
VK_COMPARE_OP_LESS_OR_EQUAL);
VkPipelineViewportStateCreateInfo viewportState =
Initializers.pipelineViewportStateCreateInfo(1, 1, 0);
VkPipelineMultisampleStateCreateInfo multisampleState =
Initializers.pipelineMultisampleStateCreateInfo(
VkSampleCountFlags.Count1,
0);
FixedArray2<VkDynamicState> dynamicStateEnables = new FixedArray2<VkDynamicState>(
VK_DYNAMIC_STATE_VIEWPORT,
VK_DYNAMIC_STATE_SCISSOR);
VkPipelineDynamicStateCreateInfo dynamicState =
Initializers.pipelineDynamicStateCreateInfo(
&dynamicStateEnables.First,
dynamicStateEnables.Count,
0);
// Solid rendering pipeline
// Load shaders
FixedArray2<VkPipelineShaderStageCreateInfo> shaderStages = new FixedArray2<VkPipelineShaderStageCreateInfo>(
loadShader(getAssetPath() + "shaders/offscreen/quad.vert.spv", VK_SHADER_STAGE_VERTEX_BIT),
loadShader(getAssetPath() + "shaders/offscreen/quad.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT));
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
Initializers.pipelineCreateInfo(
pipelineLayouts_textured,
renderPass,
0);
var vis = vertices_inputState;
pipelineCreateInfo.pVertexInputState = &vis;
pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState;
pipelineCreateInfo.pRasterizationState = &rasterizationState;
pipelineCreateInfo.pColorBlendState = &colorBlendState;
pipelineCreateInfo.pMultisampleState = &multisampleState;
pipelineCreateInfo.pViewportState = &viewportState;
pipelineCreateInfo.pDepthStencilState = &depthStencilState;
pipelineCreateInfo.pDynamicState = &dynamicState;
pipelineCreateInfo.stageCount = shaderStages.Count;
pipelineCreateInfo.pStages = &shaderStages.First;
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipelines_debug));
// Mirror
shaderStages.First = loadShader(getAssetPath() + "shaders/offscreen/mirror.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages.Second = loadShader(getAssetPath() + "shaders/offscreen/mirror.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
rasterizationState.cullMode = VK_CULL_MODE_NONE;
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipelines_mirror));
// Flip culling
rasterizationState.cullMode = VK_CULL_MODE_BACK_BIT;
// Phong shading pipelines
pipelineCreateInfo.layout = pipelineLayouts_shaded;
// Scene
shaderStages.First = loadShader(getAssetPath() + "shaders/offscreen/phong.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages.Second = loadShader(getAssetPath() + "shaders/offscreen/phong.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipelines_shaded));
// Offscreen
// Flip culling
rasterizationState.cullMode = VK_CULL_MODE_FRONT_BIT;
pipelineCreateInfo.renderPass = offscreenPass.renderPass;
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipelines_shadedOffscreen));
}
// Setup the offscreen framebuffer for rendering the blurred scene
// The color attachment of this framebuffer will then be used to sample frame in the fragment shader of the final pass
void prepareOffscreen()
{
offscreenPass.width = FB_DIM;
offscreenPass.height = FB_DIM;
// Find a suitable depth format
VkFormat fbDepthFormat;
VkBool32 validDepthFormat = Tools.getSupportedDepthFormat(physicalDevice, &fbDepthFormat);
Debug.Assert(validDepthFormat);
// Color attachment
VkImageCreateInfo image = Initializers.imageCreateInfo();
image.imageType = VK_IMAGE_TYPE_2D;
image.format = FB_COLOR_FORMAT;
image.extent.width = (uint)offscreenPass.width;
image.extent.height = (uint)offscreenPass.height;
image.extent.depth = 1;
image.mipLevels = 1;
image.arrayLayers = 1;
image.samples = VK_SAMPLE_COUNT_1_BIT;
image.tiling = VK_IMAGE_TILING_OPTIMAL;
// We will sample directly from the color attachment
image.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
VkMemoryAllocateInfo memAlloc = Initializers.memoryAllocateInfo();
VkMemoryRequirements memReqs;
Util.CheckResult(vkCreateImage(device, &image, null, out offscreenPass.color.image));
vkGetImageMemoryRequirements(device, offscreenPass.color.image, &memReqs);
memAlloc.allocationSize = memReqs.size;
memAlloc.memoryTypeIndex = vulkanDevice.getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
Util.CheckResult(vkAllocateMemory(device, &memAlloc, null, out offscreenPass.color.mem));
Util.CheckResult(vkBindImageMemory(device, offscreenPass.color.image, offscreenPass.color.mem, 0));
VkImageViewCreateInfo colorImageView = Initializers.imageViewCreateInfo();
colorImageView.viewType = VK_IMAGE_VIEW_TYPE_2D;
colorImageView.format = FB_COLOR_FORMAT;
colorImageView.subresourceRange = new VkImageSubresourceRange();
colorImageView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
colorImageView.subresourceRange.baseMipLevel = 0;
colorImageView.subresourceRange.levelCount = 1;
colorImageView.subresourceRange.baseArrayLayer = 0;
colorImageView.subresourceRange.layerCount = 1;
colorImageView.image = offscreenPass.color.image;
Util.CheckResult(vkCreateImageView(device, &colorImageView, null, out offscreenPass.color.view));
// Create sampler to sample from the attachment in the fragment shader
VkSamplerCreateInfo samplerInfo = Initializers.samplerCreateInfo();
samplerInfo.magFilter = VK_FILTER_LINEAR;
samplerInfo.minFilter = VK_FILTER_LINEAR;
samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerInfo.addressModeV = samplerInfo.addressModeU;
samplerInfo.addressModeW = samplerInfo.addressModeU;
samplerInfo.mipLodBias = 0.0f;
samplerInfo.maxAnisotropy = 0;
samplerInfo.minLod = 0.0f;
samplerInfo.maxLod = 1.0f;
samplerInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
Util.CheckResult(vkCreateSampler(device, &samplerInfo, null, out offscreenPass.sampler));
// Depth stencil attachment
image.format = fbDepthFormat;
image.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
Util.CheckResult(vkCreateImage(device, &image, null, out offscreenPass.depth.image));
vkGetImageMemoryRequirements(device, offscreenPass.depth.image, &memReqs);
memAlloc.allocationSize = memReqs.size;
memAlloc.memoryTypeIndex = vulkanDevice.getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
Util.CheckResult(vkAllocateMemory(device, &memAlloc, null, out offscreenPass.depth.mem));
Util.CheckResult(vkBindImageMemory(device, offscreenPass.depth.image, offscreenPass.depth.mem, 0));
VkImageViewCreateInfo depthStencilView = Initializers.imageViewCreateInfo();
depthStencilView.viewType = VK_IMAGE_VIEW_TYPE_2D;
depthStencilView.format = fbDepthFormat;
depthStencilView.flags = 0;
depthStencilView.subresourceRange = new VkImageSubresourceRange();
depthStencilView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
depthStencilView.subresourceRange.baseMipLevel = 0;
depthStencilView.subresourceRange.levelCount = 1;
depthStencilView.subresourceRange.baseArrayLayer = 0;
depthStencilView.subresourceRange.layerCount = 1;
depthStencilView.image = offscreenPass.depth.image;
Util.CheckResult(vkCreateImageView(device, &depthStencilView, null, out offscreenPass.depth.view));
// Create a separate render pass for the offscreen rendering as it may differ from the one used for scene rendering
FixedArray2 <VkAttachmentDescription> attchmentDescriptions = new FixedArray2 <VkAttachmentDescription>();
// Color attachment
attchmentDescriptions.First.format = FB_COLOR_FORMAT;
attchmentDescriptions.First.samples = VK_SAMPLE_COUNT_1_BIT;
attchmentDescriptions.First.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attchmentDescriptions.First.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attchmentDescriptions.First.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attchmentDescriptions.First.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attchmentDescriptions.First.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
attchmentDescriptions.First.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
// Depth attachment
attchmentDescriptions.Second.format = fbDepthFormat;
attchmentDescriptions.Second.samples = VK_SAMPLE_COUNT_1_BIT;
attchmentDescriptions.Second.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attchmentDescriptions.Second.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attchmentDescriptions.Second.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attchmentDescriptions.Second.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attchmentDescriptions.Second.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
attchmentDescriptions.Second.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
VkAttachmentReference colorReference = new VkAttachmentReference {
attachment = 0, layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
};
VkAttachmentReference depthReference = new VkAttachmentReference {
attachment = 1, layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
};
VkSubpassDescription subpassDescription = new VkSubpassDescription();
subpassDescription.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpassDescription.colorAttachmentCount = 1;
subpassDescription.pColorAttachments = &colorReference;
subpassDescription.pDepthStencilAttachment = &depthReference;
// Use subpass dependencies for layout transitions
FixedArray2 <VkSubpassDependency> dependencies = new FixedArray2 <VkSubpassDependency>();
dependencies.First.srcSubpass = VK_SUBPASS_EXTERNAL;
dependencies.First.dstSubpass = 0;
dependencies.First.srcStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
dependencies.First.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependencies.First.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT;
dependencies.First.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
dependencies.First.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
dependencies.Second.srcSubpass = 0;
dependencies.Second.dstSubpass = VK_SUBPASS_EXTERNAL;
dependencies.Second.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependencies.Second.dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
dependencies.Second.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
dependencies.Second.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
dependencies.Second.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
// Create the actual renderpass
VkRenderPassCreateInfo renderPassInfo = VkRenderPassCreateInfo.New();
renderPassInfo.attachmentCount = attchmentDescriptions.Count;
renderPassInfo.pAttachments = &attchmentDescriptions.First;
renderPassInfo.subpassCount = 1;
renderPassInfo.pSubpasses = &subpassDescription;
renderPassInfo.dependencyCount = dependencies.Count;
renderPassInfo.pDependencies = &dependencies.First;
Util.CheckResult(vkCreateRenderPass(device, &renderPassInfo, null, out offscreenPass.renderPass));
FixedArray2 <VkImageView> attachments = new FixedArray2 <VkImageView>(offscreenPass.color.view, offscreenPass.depth.view);
VkFramebufferCreateInfo fbufCreateInfo = Initializers.framebufferCreateInfo();
fbufCreateInfo.renderPass = offscreenPass.renderPass;
fbufCreateInfo.attachmentCount = 2;
fbufCreateInfo.pAttachments = &attachments.First;
fbufCreateInfo.width = (uint)offscreenPass.width;
fbufCreateInfo.height = (uint)offscreenPass.height;
fbufCreateInfo.layers = 1;
Util.CheckResult(vkCreateFramebuffer(device, &fbufCreateInfo, null, out offscreenPass.frameBuffer));
// Fill a descriptor for later use in a descriptor set
offscreenPass.descriptor.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
offscreenPass.descriptor.imageView = offscreenPass.color.view;
offscreenPass.descriptor.sampler = offscreenPass.sampler;
}
protected override void buildCommandBuffers()
{
VkCommandBufferBeginInfo cmdBufInfo = Initializers.commandBufferBeginInfo();
FixedArray2 <VkClearValue> clearValues = new FixedArray2 <VkClearValue>();
clearValues.First.color = defaultClearColor;
clearValues.Second.depthStencil = new VkClearDepthStencilValue {
depth = 1.0f, stencil = 0
};
VkRenderPassBeginInfo renderPassBeginInfo = Initializers.renderPassBeginInfo();
renderPassBeginInfo.renderPass = renderPass;
renderPassBeginInfo.renderArea.offset.x = 0;
renderPassBeginInfo.renderArea.offset.y = 0;
renderPassBeginInfo.renderArea.extent.width = width;
renderPassBeginInfo.renderArea.extent.height = height;
renderPassBeginInfo.clearValueCount = 2;
renderPassBeginInfo.pClearValues = &clearValues.First;
for (int i = 0; i < drawCmdBuffers.Count; ++i)
{
// Set target frame buffer
renderPassBeginInfo.framebuffer = frameBuffers[i];
Util.CheckResult(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));
vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VkSubpassContents.Inline);
VkViewport viewport = Initializers.viewport((float)width, (float)height, 0.0f, 1.0f);
vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
VkRect2D scissor = Initializers.rect2D(width, height, 0, 0);
vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);
// Update light positions
// w component = light radius scale
const float r = 7.5f;
float sin_t = (float)Math.Sin(Util.DegreesToRadians(timer * 360));
float cos_t = (float)Math.Cos(Util.DegreesToRadians(timer * 360));
const float y = -4.0f;
pushConstants[0] = new Vector4(r * 1.1f * sin_t, y, r * 1.1f * cos_t, 1.0f);
pushConstants[1] = new Vector4(-r * sin_t, y, -r * cos_t, 1.0f);
pushConstants[2] = new Vector4(r * 0.85f * sin_t, y, -sin_t * 2.5f, 1.5f);
pushConstants[3] = new Vector4(0.0f, y, r * 1.25f * cos_t, 1.5f);
pushConstants[4] = new Vector4(r * 2.25f * cos_t, y, 0.0f, 1.25f);
pushConstants[5] = new Vector4(r * 2.5f * (float)Math.Cos(Util.DegreesToRadians(timer * 360)), y, r * 2.5f * sin_t, 1.25f);
// Submit via push constant (rather than a UBO)
vkCmdPushConstants(
drawCmdBuffers[i],
pipelineLayout,
VkShaderStageFlags.Vertex,
0,
pushConstants.Count * (uint)sizeof(Vector4),
pushConstants.Data.ToPointer());
vkCmdBindPipeline(drawCmdBuffers[i], VkPipelineBindPoint.Graphics, pipelines_solid);
vkCmdBindDescriptorSets(drawCmdBuffers[i], VkPipelineBindPoint.Graphics, pipelineLayout, 0, 1, ref descriptorSet, 0, null);
ulong offsets = 0;
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, ref models_scene.vertices.buffer, &offsets);
vkCmdBindIndexBuffer(drawCmdBuffers[i], models_scene.indices.buffer, 0, VkIndexType.Uint32);
vkCmdDrawIndexed(drawCmdBuffers[i], models_scene.indexCount, 1, 0, 0, 0);
vkCmdEndRenderPass(drawCmdBuffers[i]);
Util.CheckResult(vkEndCommandBuffer(drawCmdBuffers[i]));
}
}
void preparePipelines()
{
VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
Initializers.pipelineInputAssemblyStateCreateInfo(
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
0,
VK_FALSE);
VkPipelineRasterizationStateCreateInfo rasterizationState =
Initializers.pipelineRasterizationStateCreateInfo(
VK_POLYGON_MODE_FILL,
VK_CULL_MODE_NONE,
VK_FRONT_FACE_COUNTER_CLOCKWISE,
0);
VkPipelineColorBlendAttachmentState blendAttachmentState =
Initializers.pipelineColorBlendAttachmentState(
0xf,
VK_FALSE);
VkPipelineColorBlendStateCreateInfo colorBlendState =
Initializers.pipelineColorBlendStateCreateInfo(
1,
&blendAttachmentState);
VkPipelineDepthStencilStateCreateInfo depthStencilState =
Initializers.pipelineDepthStencilStateCreateInfo(
VK_TRUE,
VK_TRUE,
VK_COMPARE_OP_LESS_OR_EQUAL);
VkPipelineViewportStateCreateInfo viewportState =
Initializers.pipelineViewportStateCreateInfo(1, 1, 0);
VkPipelineMultisampleStateCreateInfo multisampleState =
Initializers.pipelineMultisampleStateCreateInfo(
VK_SAMPLE_COUNT_1_BIT,
0);
FixedArray2 <VkDynamicState> dynamicStateEnables = new FixedArray2 <VkDynamicState>(
VK_DYNAMIC_STATE_VIEWPORT,
VK_DYNAMIC_STATE_SCISSOR);
VkPipelineDynamicStateCreateInfo dynamicState =
Initializers.pipelineDynamicStateCreateInfo(
&dynamicStateEnables.First,
dynamicStateEnables.Count,
0);
// Load shaders
FixedArray2 <VkPipelineShaderStageCreateInfo> shaderStages = new FixedArray2 <VkPipelineShaderStageCreateInfo>(
loadShader(getAssetPath() + "shaders/dynamicuniformbuffer/base.vert.spv", VK_SHADER_STAGE_VERTEX_BIT),
loadShader(getAssetPath() + "shaders/dynamicuniformbuffer/base.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT));
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
Initializers.pipelineCreateInfo(
pipelineLayout,
renderPass,
0);
var vis = vertices_inputState;
pipelineCreateInfo.pVertexInputState = &vis;
pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState;
pipelineCreateInfo.pRasterizationState = &rasterizationState;
pipelineCreateInfo.pColorBlendState = &colorBlendState;
pipelineCreateInfo.pMultisampleState = &multisampleState;
pipelineCreateInfo.pViewportState = &viewportState;
pipelineCreateInfo.pDepthStencilState = &depthStencilState;
pipelineCreateInfo.pDynamicState = &dynamicState;
pipelineCreateInfo.stageCount = shaderStages.Count;
pipelineCreateInfo.pStages = &shaderStages.First;
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipeline));
}
void preparePipelines()
{
VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
Initializers.pipelineInputAssemblyStateCreateInfo(
VkPrimitiveTopology.TriangleList,
0,
False);
VkPipelineRasterizationStateCreateInfo rasterizationState =
Initializers.pipelineRasterizationStateCreateInfo(
VkPolygonMode.Fill,
VkCullModeFlags.Back,
VkFrontFace.Clockwise,
0);
VkPipelineColorBlendAttachmentState blendAttachmentState =
Initializers.pipelineColorBlendAttachmentState(
(VkColorComponentFlags)0xf,
False);
VkPipelineColorBlendStateCreateInfo colorBlendState =
Initializers.pipelineColorBlendStateCreateInfo(
1,
&blendAttachmentState);
VkPipelineDepthStencilStateCreateInfo depthStencilState =
Initializers.pipelineDepthStencilStateCreateInfo(
True,
True,
VkCompareOp.LessOrEqual);
VkPipelineViewportStateCreateInfo viewportState =
Initializers.pipelineViewportStateCreateInfo(1, 1, 0);
VkPipelineMultisampleStateCreateInfo multisampleState =
Initializers.pipelineMultisampleStateCreateInfo(VkSampleCountFlags._1);
FixedArray3 <VkDynamicState> dynamicStateEnables = new FixedArray3 <VkDynamicState>(
VkDynamicState.Viewport,
VkDynamicState.Scissor,
VkDynamicState.LineWidth);
VkPipelineDynamicStateCreateInfo dynamicState =
Initializers.pipelineDynamicStateCreateInfo((VkDynamicState *)Unsafe.AsPointer(ref dynamicStateEnables), dynamicStateEnables.Count);
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
Initializers.pipelineCreateInfo(pipelineLayout, RenderPass);
FixedArray2 <VkPipelineShaderStageCreateInfo> shaderStages = new FixedArray2 <VkPipelineShaderStageCreateInfo>();
shaderStages.First = loadShader(getAssetPath() + "shaders/pipelines/phong.vert.spv", VkShaderStageFlags.Vertex);
shaderStages.Second = loadShader(getAssetPath() + "shaders/pipelines/phong.frag.spv", VkShaderStageFlags.Fragment);
pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState;
pipelineCreateInfo.pRasterizationState = &rasterizationState;
pipelineCreateInfo.pColorBlendState = &colorBlendState;
pipelineCreateInfo.pMultisampleState = &multisampleState;
pipelineCreateInfo.pViewportState = &viewportState;
pipelineCreateInfo.pDepthStencilState = &depthStencilState;
pipelineCreateInfo.pDynamicState = &dynamicState;
pipelineCreateInfo.stageCount = shaderStages.Count;
pipelineCreateInfo.pStages = (VkPipelineShaderStageCreateInfo *)Unsafe.AsPointer(ref shaderStages);
// Shared vertex bindings and attributes used by all pipelines
// Binding description
VkVertexInputBindingDescription vertexInputBindings
= Initializers.vertexInputBindingDescription(VERTEX_BUFFER_BIND_ID, vertexLayout.GetStride(), VkVertexInputRate.Vertex);
// Attribute descriptions
FixedArray4 <VkVertexInputAttributeDescription> vertexInputAttributes = new FixedArray4 <VkVertexInputAttributeDescription>
{
First = Initializers.vertexInputAttributeDescription(VERTEX_BUFFER_BIND_ID, 0, VkFormat.R32g32b32Sfloat, 0), // Location 0: Position
Second = Initializers.vertexInputAttributeDescription(VERTEX_BUFFER_BIND_ID, 1, VkFormat.R32g32b32Sfloat, sizeof(float) * 3), // Location 1: Color
Third = Initializers.vertexInputAttributeDescription(VERTEX_BUFFER_BIND_ID, 2, VkFormat.R32g32Sfloat, sizeof(float) * 6), // Location 2 : Texture coordinates
Fourth = Initializers.vertexInputAttributeDescription(VERTEX_BUFFER_BIND_ID, 3, VkFormat.R32g32b32Sfloat, sizeof(float) * 8), // Location 3 : Normal
};
VkPipelineVertexInputStateCreateInfo vertexInputState = VkPipelineVertexInputStateCreateInfo.New();
vertexInputState.vertexBindingDescriptionCount = 1;
vertexInputState.pVertexBindingDescriptions = &vertexInputBindings;
vertexInputState.vertexAttributeDescriptionCount = vertexInputAttributes.Count;
vertexInputState.pVertexAttributeDescriptions = (VkVertexInputAttributeDescription *)Unsafe.AsPointer(ref vertexInputAttributes);
pipelineCreateInfo.pVertexInputState = &vertexInputState;
// Create the graphics pipeline state objects
// We are using this pipeline as the base for the other pipelines (derivatives)
// Pipeline derivatives can be used for pipelines that share most of their state
// Depending on the implementation this may result in better performance for pipeline
// switchting and faster creation time
pipelineCreateInfo.flags = VkPipelineCreateFlags.AllowDerivatives;
// Textured pipeline
// Phong shading pipeline
shaderStages.First = loadShader(getAssetPath() + "shaders/pipelines/phong.vert.spv", VkShaderStageFlags.Vertex);
shaderStages.Second = loadShader(getAssetPath() + "shaders/pipelines/phong.frag.spv", VkShaderStageFlags.Fragment);
Util.CheckResult(vkCreateGraphicsPipelines(Device, PipelineCache, 1, ref pipelineCreateInfo, null, out pipelines_phong));
// All pipelines created after the base pipeline will be derivatives
pipelineCreateInfo.flags = VkPipelineCreateFlags.Derivative;
// Base pipeline will be our first created pipeline
pipelineCreateInfo.basePipelineHandle = pipelines_phong;
// It's only allowed to either use a handle or index for the base pipeline
// As we use the handle, we must set the index to -1 (see section 9.5 of the specification)
pipelineCreateInfo.basePipelineIndex = -1;
// Toon shading pipeline
shaderStages.First = loadShader(getAssetPath() + "shaders/pipelines/toon.vert.spv", VkShaderStageFlags.Vertex);
shaderStages.Second = loadShader(getAssetPath() + "shaders/pipelines/toon.frag.spv", VkShaderStageFlags.Fragment);
Util.CheckResult(vkCreateGraphicsPipelines(Device, PipelineCache, 1, ref pipelineCreateInfo, null, out pipelines_toon));
// Pipeline for wire frame rendering
// Non solid rendering is not a mandatory Vulkan feature
if (DeviceFeatures.fillModeNonSolid != 0)
{
rasterizationState.polygonMode = VkPolygonMode.Line;
shaderStages.First = loadShader(getAssetPath() + "shaders/pipelines/wireframe.vert.spv", VkShaderStageFlags.Vertex);
shaderStages.Second = loadShader(getAssetPath() + "shaders/pipelines/wireframe.frag.spv", VkShaderStageFlags.Fragment);
Util.CheckResult(vkCreateGraphicsPipelines(Device, PipelineCache, 1, ref pipelineCreateInfo, null, out pipelines_wireframe));
}
}
protected override void buildCommandBuffers()
{
VkCommandBufferBeginInfo cmdBufInfo = VkCommandBufferBeginInfo.New();
FixedArray2 <VkClearValue> clearValues = new FixedArray2 <VkClearValue>();
clearValues.First.color = defaultClearColor;
clearValues.Second.depthStencil = new VkClearDepthStencilValue()
{
depth = 1f, stencil = 0
};
VkRenderPassBeginInfo renderPassBeginInfo = VkRenderPassBeginInfo.New();
renderPassBeginInfo.renderPass = RenderPass;
renderPassBeginInfo.renderArea.offset.x = 0;
renderPassBeginInfo.renderArea.offset.y = 0;
renderPassBeginInfo.renderArea.extent.width = Width;
renderPassBeginInfo.renderArea.extent.height = Height;
renderPassBeginInfo.clearValueCount = 2;
renderPassBeginInfo.pClearValues = (VkClearValue *)Unsafe.AsPointer(ref clearValues);
for (int i = 0; i < DrawCmdBuffers.Count; ++i)
{
// Set target frame buffer
renderPassBeginInfo.framebuffer = Framebuffers[i];
Util.CheckResult(vkBeginCommandBuffer(DrawCmdBuffers[i], ref cmdBufInfo));
vkCmdBeginRenderPass(DrawCmdBuffers[i], ref renderPassBeginInfo, VkSubpassContents.Inline);
VkViewport viewport = new VkViewport()
{
width = Width, height = Height, minDepth = 0f, maxDepth = 1f
};
vkCmdSetViewport(DrawCmdBuffers[i], 0, 1, ref viewport);
VkRect2D scissor = new VkRect2D()
{
extent = new VkExtent2D()
{
width = Width, height = Height
}, offset = new VkOffset2D()
};
vkCmdSetScissor(DrawCmdBuffers[i], 0, 1, ref scissor);
vkCmdBindDescriptorSets(DrawCmdBuffers[i], VkPipelineBindPoint.Graphics, pipelineLayout, 0, 1, ref descriptorSet, 0, null);
ulong offsets = 0;
vkCmdBindVertexBuffers(DrawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, ref models_cube.vertices.buffer, ref offsets);
vkCmdBindIndexBuffer(DrawCmdBuffers[i], models_cube.indices.buffer, 0, VkIndexType.Uint32);
// Left : Solid colored
viewport.width = Width / 3.0f;
vkCmdSetViewport(DrawCmdBuffers[i], 0, 1, &viewport);
vkCmdBindPipeline(DrawCmdBuffers[i], VkPipelineBindPoint.Graphics, pipelines_phong);
vkCmdDrawIndexed(DrawCmdBuffers[i], models_cube.indexCount, 1, 0, 0, 0);
// Center : Toon
viewport.x = Width / 3.0f;
vkCmdSetViewport(DrawCmdBuffers[i], 0, 1, &viewport);
vkCmdBindPipeline(DrawCmdBuffers[i], VkPipelineBindPoint.Graphics, pipelines_toon);
// Line Width > 1.0f only if wide lines feature is supported
if (DeviceFeatures.wideLines != 0)
{
vkCmdSetLineWidth(DrawCmdBuffers[i], 2.0f);
}
vkCmdDrawIndexed(DrawCmdBuffers[i], models_cube.indexCount, 1, 0, 0, 0);
if (DeviceFeatures.fillModeNonSolid != 0)
{
// Right : Wireframe
viewport.x = Width / 3.0f + Width / 3.0f;
vkCmdSetViewport(DrawCmdBuffers[i], 0, 1, &viewport);
vkCmdBindPipeline(DrawCmdBuffers[i], VkPipelineBindPoint.Graphics, pipelines_wireframe);
vkCmdDrawIndexed(DrawCmdBuffers[i], models_cube.indexCount, 1, 0, 0, 0);
}
vkCmdEndRenderPass(DrawCmdBuffers[i]);
Util.CheckResult(vkEndCommandBuffer(DrawCmdBuffers[i]));
}
}
void preparePipelines()
{
VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
Initializers.pipelineInputAssemblyStateCreateInfo(
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
0,
False);
VkPipelineRasterizationStateCreateInfo rasterizationState =
Initializers.pipelineRasterizationStateCreateInfo(
VK_POLYGON_MODE_FILL,
VK_CULL_MODE_NONE,
VK_FRONT_FACE_CLOCKWISE,
0);
VkPipelineColorBlendAttachmentState blendAttachmentState =
Initializers.pipelineColorBlendAttachmentState(
0xf,
False);
VkPipelineColorBlendStateCreateInfo colorBlendState =
Initializers.pipelineColorBlendStateCreateInfo(
1,
&blendAttachmentState);
VkPipelineDepthStencilStateCreateInfo depthStencilState =
Initializers.pipelineDepthStencilStateCreateInfo(
True,
True,
VK_COMPARE_OP_LESS_OR_EQUAL);
VkPipelineViewportStateCreateInfo viewportState =
Initializers.pipelineViewportStateCreateInfo(1, 1, 0);
VkPipelineMultisampleStateCreateInfo multisampleState =
Initializers.pipelineMultisampleStateCreateInfo(
VK_SAMPLE_COUNT_1_BIT,
0);
FixedArray3 <VkDynamicState> dynamicStateEnables = new FixedArray3 <VkDynamicState>(
VK_DYNAMIC_STATE_VIEWPORT,
VK_DYNAMIC_STATE_SCISSOR,
VK_DYNAMIC_STATE_LINE_WIDTH);
VkPipelineDynamicStateCreateInfo dynamicState =
Initializers.pipelineDynamicStateCreateInfo(
&dynamicStateEnables.First,
dynamicStateEnables.Count,
0);
FixedArray2 <VkPipelineShaderStageCreateInfo> shaderStages = new FixedArray2 <VkPipelineShaderStageCreateInfo>();
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
Initializers.pipelineCreateInfo(
pipelineLayout,
renderPass,
0);
var vis = vertices_inputState;
pipelineCreateInfo.pVertexInputState = &vis;
pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState;
pipelineCreateInfo.pRasterizationState = &rasterizationState;
pipelineCreateInfo.pColorBlendState = &colorBlendState;
pipelineCreateInfo.pMultisampleState = &multisampleState;
pipelineCreateInfo.pViewportState = &viewportState;
pipelineCreateInfo.pDepthStencilState = &depthStencilState;
pipelineCreateInfo.pDynamicState = &dynamicState;
pipelineCreateInfo.stageCount = shaderStages.Count;
pipelineCreateInfo.pStages = &shaderStages.First;
// Prepare specialization data
SpecializationData specializationData = SpecializationData.Default;
// Each shader constant of a shader stage corresponds to one map entry
FixedArray2 <VkSpecializationMapEntry> specializationMapEntries = new FixedArray2 <VkSpecializationMapEntry>();
// Shader bindings based on specialization constants are marked by the new "constant_id" layout qualifier:
// layout (constant_id = 0) const int LIGHTING_MODEL = 0;
// layout (constant_id = 1) const float PARAM_TOON_DESATURATION = 0.0f;
// Map entry for the lighting model to be used by the fragment shader
specializationMapEntries.First.constantID = 0;
specializationMapEntries.First.size = (UIntPtr)sizeof(uint);
specializationMapEntries.First.offset = 0;
// Map entry for the toon shader parameter
specializationMapEntries.Second.constantID = 1;
specializationMapEntries.Second.size = (UIntPtr)sizeof(float);
specializationMapEntries.Second.offset = (sizeof(uint));
// Prepare specialization info block for the shader stage
VkSpecializationInfo specializationInfo = new VkSpecializationInfo();
specializationInfo.dataSize = (UIntPtr)sizeof(SpecializationData);
specializationInfo.mapEntryCount = specializationMapEntries.Count;
specializationInfo.pMapEntries = &specializationMapEntries.First;
specializationInfo.pData = &specializationData;
// Create pipelines
// All pipelines will use the same "uber" shader and specialization constants to change branching and parameters of that shader
shaderStages.First = loadShader(getAssetPath() + "shaders/specializationconstants/uber.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages.Second = loadShader(getAssetPath() + "shaders/specializationconstants/uber.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
// Specialization info is assigned is part of the shader stage (modul) and must be set after creating the module and before creating the pipeline
shaderStages.Second.pSpecializationInfo = &specializationInfo;
// Solid phong shading
specializationData.lightingModel = 0;
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipelines_phong));
// Phong and textured
specializationData.lightingModel = 1;
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipelines_toon));
// Textured discard
specializationData.lightingModel = 2;
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipelines_textured));
}
void preparePipelines()
{
VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
Initializers.pipelineInputAssemblyStateCreateInfo(
VkPrimitiveTopology.TriangleList,
0,
False);
VkPipelineRasterizationStateCreateInfo rasterizationState =
Initializers.pipelineRasterizationStateCreateInfo(
VkPolygonMode.Fill,
VkCullModeFlags.Back,
VkFrontFace.CounterClockwise,
0);
VkPipelineColorBlendAttachmentState blendAttachmentState =
Initializers.pipelineColorBlendAttachmentState(
(VkColorComponentFlags)0xf,
False);
VkPipelineColorBlendStateCreateInfo colorBlendState =
Initializers.pipelineColorBlendStateCreateInfo(
1,
&blendAttachmentState);
VkPipelineDepthStencilStateCreateInfo depthStencilState =
Initializers.pipelineDepthStencilStateCreateInfo(
False,
False,
VkCompareOp.LessOrEqual);
VkPipelineViewportStateCreateInfo viewportState =
Initializers.pipelineViewportStateCreateInfo(1, 1, 0);
VkPipelineMultisampleStateCreateInfo multisampleState =
Initializers.pipelineMultisampleStateCreateInfo(
VkSampleCountFlags.Count1,
0);
FixedArray2<VkDynamicState> dynamicStateEnables = new FixedArray2<VkDynamicState>(
VkDynamicState.Viewport,
VkDynamicState.Scissor);
VkPipelineDynamicStateCreateInfo dynamicState =
Initializers.pipelineDynamicStateCreateInfo(
&dynamicStateEnables.First,
dynamicStateEnables.Count,
0);
// Skybox pipeline (background cube)
FixedArray2<VkPipelineShaderStageCreateInfo> shaderStages = new FixedArray2<VkPipelineShaderStageCreateInfo>(
loadShader(getAssetPath() + "shaders/cubemap/skybox.vert.spv", VkShaderStageFlags.Vertex),
loadShader(getAssetPath() + "shaders/cubemap/skybox.frag.spv", VkShaderStageFlags.Fragment));
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
Initializers.pipelineCreateInfo(
pipelineLayout,
renderPass,
0);
var inputState = vertices.inputState;
pipelineCreateInfo.pVertexInputState = &inputState;
pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState;
pipelineCreateInfo.pRasterizationState = &rasterizationState;
pipelineCreateInfo.pColorBlendState = &colorBlendState;
pipelineCreateInfo.pMultisampleState = &multisampleState;
pipelineCreateInfo.pViewportState = &viewportState;
pipelineCreateInfo.pDepthStencilState = &depthStencilState;
pipelineCreateInfo.pDynamicState = &dynamicState;
pipelineCreateInfo.stageCount = shaderStages.Count;
pipelineCreateInfo.pStages = &shaderStages.First;
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipelines_skybox));
// Cube map reflect pipeline
shaderStages.First = loadShader(getAssetPath() + "shaders/cubemap/reflect.vert.spv", VkShaderStageFlags.Vertex);
shaderStages.Second = loadShader(getAssetPath() + "shaders/cubemap/reflect.frag.spv", VkShaderStageFlags.Fragment);
// Enable depth test and write
depthStencilState.depthWriteEnable = True;
depthStencilState.depthTestEnable = True;
// Flip cull mode
rasterizationState.cullMode = VkCullModeFlags.Front;
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipelines_reflect));
}
void preparePipelines()
{
VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
Initializers.pipelineInputAssemblyStateCreateInfo(
VkPrimitiveTopology.TriangleList,
0,
False);
VkPipelineRasterizationStateCreateInfo rasterizationState =
Initializers.pipelineRasterizationStateCreateInfo(
VkPolygonMode.Fill,
VkCullModeFlags.None,
VkFrontFace.CounterClockwise,
0);
VkPipelineColorBlendAttachmentState blendAttachmentState =
Initializers.pipelineColorBlendAttachmentState(
(VkColorComponentFlags)0xf,
False);
VkPipelineColorBlendStateCreateInfo colorBlendState =
Initializers.pipelineColorBlendStateCreateInfo(
1,
&blendAttachmentState);
VkPipelineDepthStencilStateCreateInfo depthStencilState =
Initializers.pipelineDepthStencilStateCreateInfo(
True,
True,
VkCompareOp.LessOrEqual);
VkPipelineViewportStateCreateInfo viewportState =
Initializers.pipelineViewportStateCreateInfo(1, 1, 0);
VkPipelineMultisampleStateCreateInfo multisampleState =
Initializers.pipelineMultisampleStateCreateInfo(
VkSampleCountFlags.Count1,
0);
FixedArray2 <VkDynamicState> dynamicStateEnables = new FixedArray2 <VkDynamicState>(
VkDynamicState.Viewport,
VkDynamicState.Scissor);
VkPipelineDynamicStateCreateInfo dynamicState =
Initializers.pipelineDynamicStateCreateInfo(
(VkDynamicState *)Unsafe.AsPointer(ref dynamicStateEnables),
dynamicStateEnables.Count,
0);
// Load shaders
FixedArray2 <VkPipelineShaderStageCreateInfo> shaderStages = new FixedArray2 <VkPipelineShaderStageCreateInfo>();
shaderStages.First = loadShader(getAssetPath() + "shaders/texture/texture.vert.spv", VkShaderStageFlags.Vertex);
shaderStages.Second = loadShader(getAssetPath() + "shaders/texture/texture.frag.spv", VkShaderStageFlags.Fragment);
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
Initializers.pipelineCreateInfo(
pipelineLayout,
renderPass,
0);
var vertexInputState = vertices.inputState;
pipelineCreateInfo.pVertexInputState = &vertexInputState;
pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState;
pipelineCreateInfo.pRasterizationState = &rasterizationState;
pipelineCreateInfo.pColorBlendState = &colorBlendState;
pipelineCreateInfo.pMultisampleState = &multisampleState;
pipelineCreateInfo.pViewportState = &viewportState;
pipelineCreateInfo.pDepthStencilState = &depthStencilState;
pipelineCreateInfo.pDynamicState = &dynamicState;
pipelineCreateInfo.stageCount = shaderStages.Count;
pipelineCreateInfo.pStages = (VkPipelineShaderStageCreateInfo *)Unsafe.AsPointer(ref shaderStages);
Util.CheckResult(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, null, out pipelines_solid));
}
