sleepy-day/VulkanRenderer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update descriptor handling

Browse Source
This commit is contained in:
Matthew 2025-11-06 07:48:24 +11:00
parent 614ee40d85
commit b4d7f4fb16
1 changed files with 161 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

407
vulkan.d
View File

@ -3,9 +3,9 @@ import vulkan_logging;
import vulkan_util; import vulkan_util;
import std.stdio; import std.stdio;
import std.algorithm.comparison; import std.algorithm.comparison;
import core.stdc.string : strcmp, memcpy; import core.stdc.string : strcmp, memcpy;
import core.stdc.stdio : Printf = printf; import core.stdc.stdio : Printf = printf;
import std.format : sformat; import std.format : sformat;
import std.math.rounding : Ceil = ceil; import std.math.rounding : Ceil = ceil;
version(VULKAN_DEBUG) version(VULKAN_DEBUG)
@ -17,17 +17,17 @@ else
const BUILD_DEBUG = false; const BUILD_DEBUG = false;
} }
alias InitRenderer = Init; alias InitRenderer = Init;
alias Renderer = Vulkan; alias Renderer = Vulkan;
alias Shader = VkShaderModule; alias Shader = VkShaderModule;
alias Pipeline = u32; alias Pipeline = u32;
alias Attribute = VkVertexInputAttributeDescription; alias Attribute = VkVertexInputAttributeDescription;
alias SpecEntry = VkSpecializationMapEntry; alias SpecEntry = VkSpecializationMapEntry;
alias RenderPass = VkRenderPass; alias RenderPass = VkRenderPass;
alias DescSetLayout = VkDescriptorSetLayout; alias DescSetLayout = VkDescriptorSetLayout;
alias PipelineLayout = VkPipelineLayout; alias PipelineLayout = VkPipelineLayout;
alias DescLayoutBinding = VkDescriptorSetLayoutBinding; alias DescLayoutBinding = VkDescriptorSetLayoutBinding;
alias DescWrite = VkWriteDescriptorSet; alias DescWrite = VkWriteDescriptorSet;
struct DescSet struct DescSet
{ {
@ -45,16 +45,13 @@ else
bool g_DEBUG_PRINTF = false; bool g_DEBUG_PRINTF = false;
} }
const FRAME_OVERLAP = 2; const FRAME_OVERLAP = 2;
const MAX_SETS = 1000; const MAX_SETS = 1000;
const DESC_ARRAY_SIZE = 256; const DESC_ARRAY_SIZE = 256;
version(linux) version(linux)
{ {
const string[] VULKAN_LIBS = [ const string[] VULKAN_LIBS = [ "libvulkan.so.1", "libvulkan.so" ];
"libvulkan.so.1",
"libvulkan.so",
];
struct PlatformHandles struct PlatformHandles
{ {
@ -65,9 +62,7 @@ version(linux)
version(Windows) version(Windows)
{ {
const string[] VULKAN_LIBS = [ const string[] VULKAN_LIBS = [ "vulkan-1.dll" ];
"vulkan-1.dll",
];
struct PlatformHandles struct PlatformHandles
{ {
@ -118,18 +113,18 @@ const VkFormat[] VK_IMAGE_FORMATS = [
enum ShaderStage : VkShaderStageFlagBits enum ShaderStage : VkShaderStageFlagBits
{ {
None = cast(VkShaderStageFlagBits)0, None = cast(VkShaderStageFlagBits)0,
Vertex = VK_SHADER_STAGE_VERTEX_BIT, Vertex = VK_SHADER_STAGE_VERTEX_BIT,
Fragment = VK_SHADER_STAGE_FRAGMENT_BIT, Fragment = VK_SHADER_STAGE_FRAGMENT_BIT,
Compute = VK_SHADER_STAGE_COMPUTE_BIT, Compute = VK_SHADER_STAGE_COMPUTE_BIT,
All = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT, All = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT,
} }
alias SS = ShaderStage; alias SS = ShaderStage;
enum InputRate : int enum InputRate : int
{ {
Vertex = VK_VERTEX_INPUT_RATE_VERTEX, Vertex = VK_VERTEX_INPUT_RATE_VERTEX,
Instance = VK_VERTEX_INPUT_RATE_INSTANCE, Instance = VK_VERTEX_INPUT_RATE_INSTANCE,
} }
@ -137,13 +132,12 @@ alias IR = InputRate;
enum ImageUsage : VkImageUsageFlagBits enum ImageUsage : VkImageUsageFlagBits
{ {
None = cast(VkImageUsageFlagBits)0, None = cast(VkImageUsageFlagBits)0,
Draw = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | Draw = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, Depth = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
Depth = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, Texture = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
Texture = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, Convert = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
Convert = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, Storage = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
Storage = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
Swapchain = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, Swapchain = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
} }
@ -152,36 +146,36 @@ alias IU = ImageUsage;
enum FrontFace: VkFrontFace enum FrontFace: VkFrontFace
{ {
CCW = VK_FRONT_FACE_COUNTER_CLOCKWISE, CCW = VK_FRONT_FACE_COUNTER_CLOCKWISE,
CW = VK_FRONT_FACE_CLOCKWISE, CW = VK_FRONT_FACE_CLOCKWISE,
} }
alias FF = FrontFace; alias FF = FrontFace;
enum Format : VkFormat enum Format : VkFormat
{ {
UINT = VK_FORMAT_R32_UINT, UINT = VK_FORMAT_R32_UINT,
R_F32 = VK_FORMAT_R32_SFLOAT, R_F32 = VK_FORMAT_R32_SFLOAT,
RG_F32 = VK_FORMAT_R32G32_SFLOAT, RG_F32 = VK_FORMAT_R32G32_SFLOAT,
RGB_F32 = VK_FORMAT_R32G32B32_SFLOAT, RGB_F32 = VK_FORMAT_R32G32B32_SFLOAT,
RGBA_F32 = VK_FORMAT_R32G32B32A32_SFLOAT, RGBA_F32 = VK_FORMAT_R32G32B32A32_SFLOAT,
RGBA_UINT = VK_FORMAT_B8G8R8A8_UINT, RGBA_UINT = VK_FORMAT_B8G8R8A8_UINT,
R_U32 = VK_FORMAT_R32_UINT, R_U32 = VK_FORMAT_R32_UINT,
RG_U32 = VK_FORMAT_R32G32_UINT, RG_U32 = VK_FORMAT_R32G32_UINT,
RGBA_UNORM = VK_FORMAT_R8G8B8A8_UNORM, RGBA_UNORM = VK_FORMAT_R8G8B8A8_UNORM,
RGBA_SRGB = VK_FORMAT_R8G8B8A8_SRGB, RGBA_SRGB = VK_FORMAT_R8G8B8A8_SRGB,
D_SF32 = VK_FORMAT_D32_SFLOAT, D_SF32 = VK_FORMAT_D32_SFLOAT,
} }
alias FMT = Format; alias FMT = Format;
enum BufferType : VkBufferUsageFlagBits enum BufferType : VkBufferUsageFlagBits
{ {
None = cast(VkBufferUsageFlagBits)0, None = cast(VkBufferUsageFlagBits)0,
Vertex = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, Vertex = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
Index = VK_BUFFER_USAGE_INDEX_BUFFER_BIT, Index = VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
Uniform = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, Uniform = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
Storage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, Storage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
Staging = VK_BUFFER_USAGE_TRANSFER_SRC_BIT, Staging = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
BufferView = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, BufferView = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT,
} }
@ -189,8 +183,8 @@ alias BT = BufferType;
enum ImageLayout : VkImageLayout enum ImageLayout : VkImageLayout
{ {
Undefined = VK_IMAGE_LAYOUT_UNDEFINED, Undefined = VK_IMAGE_LAYOUT_UNDEFINED,
General = VK_IMAGE_LAYOUT_GENERAL, General = VK_IMAGE_LAYOUT_GENERAL,
ColorAttach = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, ColorAttach = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
} }
@ -208,7 +202,7 @@ struct Image
struct BufferView struct BufferView
{ {
Buffer base; Buffer base;
VkBufferView view; VkBufferView view;
alias base this; alias base this;
@ -216,7 +210,7 @@ struct BufferView
struct ImageView struct ImageView
{ {
Image base; Image base;
VkImageView view; VkImageView view;
alias base this; alias base this;
@ -230,6 +224,19 @@ struct Buffer
bool dynamic; bool dynamic;
} }
struct Descriptor
{
DescType type;
u32 binding;
union
{
Buffer buf;
Image image;
ImageView view;
BufferView buf_view;
}
}
struct ShaderUniforms struct ShaderUniforms
{ {
f32 placeholder; f32 placeholder;
@ -245,36 +252,36 @@ alias PT = PipelineType;
enum BlendFactor : VkBlendFactor enum BlendFactor : VkBlendFactor
{ {
Zero = VK_BLEND_FACTOR_ZERO, Zero = VK_BLEND_FACTOR_ZERO,
One = VK_BLEND_FACTOR_ONE, One = VK_BLEND_FACTOR_ONE,
SrcColor = VK_BLEND_FACTOR_SRC_COLOR, SrcColor = VK_BLEND_FACTOR_SRC_COLOR,
OneMinusSrcColor = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR, OneMinusSrcColor = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR,
DstColor = VK_BLEND_FACTOR_DST_COLOR, DstColor = VK_BLEND_FACTOR_DST_COLOR,
OneMinusDstColor = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR, OneMinusDstColor = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR,
SrcAlpha = VK_BLEND_FACTOR_SRC_ALPHA, SrcAlpha = VK_BLEND_FACTOR_SRC_ALPHA,
OneMinusSrcAlpha = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, OneMinusSrcAlpha = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
DstAlpha = VK_BLEND_FACTOR_DST_ALPHA, DstAlpha = VK_BLEND_FACTOR_DST_ALPHA,
OneMinusDstAlpha = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, OneMinusDstAlpha = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA,
ConstColor = VK_BLEND_FACTOR_CONSTANT_COLOR, ConstColor = VK_BLEND_FACTOR_CONSTANT_COLOR,
OneMinusConstColor = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, OneMinusConstColor = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR,
ConstAlpha = VK_BLEND_FACTOR_CONSTANT_ALPHA, ConstAlpha = VK_BLEND_FACTOR_CONSTANT_ALPHA,
OneMinusConstAlpha = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, OneMinusConstAlpha = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA,
SrcAlphaSaturate = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, SrcAlphaSaturate = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE,
Src1Color = VK_BLEND_FACTOR_SRC1_COLOR, Src1Color = VK_BLEND_FACTOR_SRC1_COLOR,
OneMinusSrc1Color = VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, OneMinusSrc1Color = VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR,
Src1Alpha = VK_BLEND_FACTOR_SRC1_ALPHA, Src1Alpha = VK_BLEND_FACTOR_SRC1_ALPHA,
OneMinusSrc1Alpha = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, OneMinusSrc1Alpha = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
} }
alias BF = BlendFactor; alias BF = BlendFactor;
enum BlendOp : VkBlendOp enum BlendOp : VkBlendOp
{ {
Add = VK_BLEND_OP_ADD, Add = VK_BLEND_OP_ADD,
Sub = VK_BLEND_OP_SUBTRACT, Sub = VK_BLEND_OP_SUBTRACT,
ReverseSub = VK_BLEND_OP_REVERSE_SUBTRACT, ReverseSub = VK_BLEND_OP_REVERSE_SUBTRACT,
Min = VK_BLEND_OP_MIN, Min = VK_BLEND_OP_MIN,
Max = VK_BLEND_OP_MAX, Max = VK_BLEND_OP_MAX,
} }
alias BO = BlendOp; alias BO = BlendOp;
@ -350,20 +357,10 @@ enum DescType : VkDescriptorType
alias DT = DescType; alias DT = DescType;
enum PresentMode : VkPresentModeKHR
{
Vsync = VK_PRESENT_MODE_FIFO_KHR,
NoVsync = VK_PRESENT_MODE_IMMEDIATE_KHR,
VsyncUncapped = VK_PRESENT_MODE_MAILBOX_KHR,
VsyncRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
Max,
}
struct MappedBuffer(T) struct MappedBuffer(T)
{ {
Buffer base; Buffer base;
T[] data; T[] data;
u64 offset; u64 offset;
alias base this; alias base this;
@ -371,38 +368,36 @@ struct MappedBuffer(T)
struct Vulkan struct Vulkan
{ {
Arena arena; Arena arena;
Arena[FRAME_OVERLAP] frame_arenas; Arena[FRAME_OVERLAP] frame_arenas;
u32 frame_index; u32 frame_index;
u32 semaphore_index; u32 semaphore_index;
SLList!(SI) cleanup_list; SLList!(SI) cleanup_list;
PlatformHandles platform_handles; PlatformHandles platform_handles;
u32 window_h, window_w; u32 window_h, window_w;
VkDebugUtilsMessengerEXT dbg_msg; VkDebugUtilsMessengerEXT dbg_msg;
VkInstance instance; VkInstance instance;
VkSurfaceKHR surface; VkSurfaceKHR surface;
VkPhysicalDevice physical_device; VkPhysicalDevice physical_device;
VkDevice device; VkDevice device;
VmaAllocator vma; VmaAllocator vma;
VkSwapchainKHR swapchain; VkSwapchainKHR swapchain;
VkSurfaceFormatKHR surface_format; VkSurfaceFormatKHR surface_format;
PresentMode present_mode; VkPresentModeKHR present_mode;
VkExtent3D swapchain_extent; VkExtent3D swapchain_extent;
PresentMode[] present_modes;
bool swapchain_dirty;
VkRenderPass render_pass; VkRenderPass render_pass;
VkFramebuffer framebuffer; VkFramebuffer framebuffer;
ImageView[] present_images; ImageView[] present_images;
u32 image_index; u32 image_index;
ImageView draw_image; ImageView draw_image;
ImageView depth_image; ImageView depth_image;
VkCommandPool[FRAME_OVERLAP] cmd_pools; VkCommandPool[FRAME_OVERLAP] cmd_pools;
VkCommandBuffer[FRAME_OVERLAP] cmds; VkCommandBuffer[FRAME_OVERLAP] cmds;
@ -411,9 +406,9 @@ struct Vulkan
VkCommandBuffer comp_cmd; VkCommandBuffer comp_cmd;
VkFence comp_fence; VkFence comp_fence;
VkSemaphore[] submit_sems; VkSemaphore[] submit_sems;
VkSemaphore[FRAME_OVERLAP] acquire_sems; VkSemaphore[FRAME_OVERLAP] acquire_sems;
VkFence[FRAME_OVERLAP] render_fences; VkFence[FRAME_OVERLAP] render_fences;
VkCommandPool imm_pool; VkCommandPool imm_pool;
VkCommandBuffer imm_cmd; VkCommandBuffer imm_cmd;
@ -470,9 +465,9 @@ struct PipelineHandles
struct QueueInfo struct QueueInfo
{ {
i32 gfx_index, tfer_index; i32 gfx_index, tfer_index;
VkQueue gfx_queue, tfer_queue; VkQueue gfx_queue, tfer_queue;
bool single_queue; bool single_queue;
} }
u8[] CONVERT_SHADER_BYTES = cast(u8[])import("convert.comp.spv"); u8[] CONVERT_SHADER_BYTES = cast(u8[])import("convert.comp.spv");
@ -765,12 +760,7 @@ BeginFrame(Vulkan* vk)
VkCheckA("BeginFrame failure: vkResetFences error", result); VkCheckA("BeginFrame failure: vkResetFences error", result);
result = vkAcquireNextImageKHR(vk.device, vk.swapchain, 1000000000, vk.acquire_sems[vk.frame_index], null, &vk.image_index); result = vkAcquireNextImageKHR(vk.device, vk.swapchain, 1000000000, vk.acquire_sems[vk.frame_index], null, &vk.image_index);
if(vk.swapchain_dirty && (result == VK_SUCCESS || result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR)) if(result == VK_ERROR_OUT_OF_DATE_KHR)
{
RecreateSwapchain(vk);
vk.swapchain_dirty = false;
}
else if(result == VK_ERROR_OUT_OF_DATE_KHR)
{ {
RecreateSwapchain(vk); RecreateSwapchain(vk);
} }
@ -2264,102 +2254,49 @@ InitGlobalDescSet(Vulkan* vk)
} }
void void
Write(Vulkan* vk, DescSet set, ImageView* view, u32 binding, DescType type) Write(Vulkan* vk, DescSet set, Descriptor[] descs)
{ {
VkDescriptorImageInfo info = { Arena* arena = vk.frame_arenas.ptr + vk.frame_index;
imageView: view.view,
imageLayout: view.layout,
};
VkWriteDescriptorSet write = { VkWriteDescriptorSet[] writes = Alloc!(VkWriteDescriptorSet)(arena, descs.length);
sType: VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
dstSet: set.handle,
dstBinding: binding,
descriptorCount: 1,
descriptorType: type,
pImageInfo: &info,
};
vkUpdateDescriptorSets(vk.device, 1, &write, 0, null); for(u64 i = 0; i < descs.length; i += 1)
} {
VkWriteDescriptorSet* write = writes.ptr + i;
void write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
Write(Vulkan* vk, DescSet set, Buffer* buffer, u32 binding, DescType type) write.descriptorType = descs[i].type;
{ write.dstSet = set;
VkDescriptorBufferInfo info = { write.dstBinding = descs[i].binding;
buffer: buffer.buffer, write.descriptorCount = 1;
range: buffer.size,
offset: 0,
};
VkWriteDescriptorSet write = { switch(descs[i].type) with(DescType)
sType: VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
dstSet: set.handle,
dstBinding: binding,
descriptorCount: 1,
descriptorType: type,
pBufferInfo: &info,
};
vkUpdateDescriptorSets(vk.device, 1, &write, 0, null);
}
void
Write(Vulkan* vk, DescSet set, Buffer* buffer, u32 binding, u32 index, DescType type)
{
VkDescriptorBufferInfo info = {
buffer: buffer.buffer,
range: buffer.size,
offset: 0,
};
VkWriteDescriptorSet write = {
sType: VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
dstSet: set.handle,
dstBinding: binding,
dstArrayElement: index,
descriptorCount: 1,
descriptorType: type,
pBufferInfo: &info,
};
vkUpdateDescriptorSets(vk.device, 1, &write, 0, null);
}
void
WriteGUI(Vulkan* vk, DescSet set, ImageView* atlas, Buffer* buf)
{
VkDescriptorImageInfo image_info = {
imageView: atlas.view,
imageLayout: atlas.layout,
};
VkDescriptorBufferInfo buf_info = {
buffer: buf.buffer,
range: buf.size,
offset: 0,
};
VkWriteDescriptorSet[2] writes = [
{ {
sType: VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, case Image, StorageImage, InputAttach:
dstSet: set.handle, {
dstBinding: 0, VkDescriptorImageInfo* info = Alloc!(VkDescriptorImageInfo)(arena);
descriptorCount: 1,
descriptorType: VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, info.imageView = descs[i].view.view;
pImageInfo: &image_info, info.imageLayout = descs[i].view.layout;
}, write.pImageInfo = info;
{ } break;
sType: VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, case Uniform, Storage:
dstSet: set.handle, {
dstBinding: 1, VkDescriptorBufferInfo* info = Alloc!(VkDescriptorBufferInfo)(arena);
descriptorCount: 1,
descriptorType: VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, info.buffer = descs[i].buf.buffer;
pBufferInfo: &buf_info, info.offset = cast(VkDeviceSize)0;
info.range = cast(VkDeviceSize)descs[i].buf.size;
write.pBufferInfo = info;
} break;
case UniformTexelBuf, StorageTexelBuf:
{
write.pTexelBufferView = &descs[i].buf_view.view;
} break;
} }
]; }
vkUpdateDescriptorSets(vk.device, cast(u32)writes.length, writes.ptr, 0, null); vkUpdateDescriptorSets(vk.device, writes.length, writes.ptr, 0, null);
} }
void void
@ -2643,8 +2580,18 @@ SelectSwapchainFormats(Vulkan* vk)
u32 mode_count; u32 mode_count;
vkGetPhysicalDeviceSurfacePresentModesKHR(vk.physical_device, vk.surface, &mode_count, null); vkGetPhysicalDeviceSurfacePresentModesKHR(vk.physical_device, vk.surface, &mode_count, null);
vk.present_modes = Alloc!(PresentMode)(arena, mode_count); VkPresentModeKHR[] modes = Alloc!(VkPresentModeKHR)(arena, mode_count);
vkGetPhysicalDeviceSurfacePresentModesKHR(vk.physical_device, vk.surface, &mode_count, cast(VkPresentModeKHR*)vk.present_modes.ptr); vkGetPhysicalDeviceSurfacePresentModesKHR(vk.physical_device, vk.surface, &mode_count, modes.ptr);
VkPresentModeKHR present_mode = VK_PRESENT_MODE_FIFO_KHR;
foreach(mode; modes)
{
if(mode == VK_PRESENT_MODE_MAILBOX_KHR)
{
present_mode = VK_PRESENT_MODE_MAILBOX_KHR;
break;
}
}
VkSurfaceFormatKHR surface_format = formats[0]; VkSurfaceFormatKHR surface_format = formats[0];
foreach(format; formats) foreach(format; formats)
@ -2657,39 +2604,7 @@ SelectSwapchainFormats(Vulkan* vk)
} }
vk.surface_format = surface_format; vk.surface_format = surface_format;
vk.present_mode = PresentMode.Vsync; vk.present_mode = present_mode;
}
PresentMode[]
AvailablePresentModes(Vulkan* vk)
{
return vk.present_modes;
}
bool
SetPresentMode(Vulkan* vk, PresentMode mode)
{
bool result = false;
foreach(pm; vk.present_modes)
{
if(pm == mode)
{
result = true;
break;
}
}
if(result)
{
if(vk.present_mode != mode)
{
vk.swapchain_dirty = true;
}
vk.present_mode = mode;
}
return result;
} }
bool bool