]> git.tdb.fi Git - libs/gl.git/blob - source/backends/vulkan/commands_backend.cpp
Cache framebuffer and viewport in VulkanCommands
[libs/gl.git] / source / backends / vulkan / commands_backend.cpp
1 #include <msp/core/hash.h>
2 #include <msp/graphics/vulkancontext_platform.h>
3 #include "batch.h"
4 #include "commands_backend.h"
5 #include "device.h"
6 #include "error.h"
7 #include "framebuffer.h"
8 #include "frameformat.h"
9 #include "pipelinestate.h"
10 #include "rect.h"
11 #include "semaphore.h"
12 #include "swapchaintexture.h"
13 #include "vulkan.h"
14
15 using namespace std;
16
17 namespace Msp {
18 namespace GL {
19
20 VulkanCommands::VulkanCommands():
21         device(Device::get_current())
22 { }
23
24 VulkanCommands::~VulkanCommands()
25 {
26         const VulkanFunctions &vk = device.get_functions();
27
28         vk.QueueWaitIdle();
29 }
30
31 void VulkanCommands::begin_buffer()
32 {
33         if(!current_pool)
34                 throw invalid_operation("VulkanCommands::begin_buffer");
35
36         const VulkanFunctions &vk = device.get_functions();
37
38         if(!current_pool->in_use)
39         {
40                 current_pool->fence.reset();
41                 current_pool->in_use = true;
42         }
43
44         VkCommandBufferAllocateInfo alloc_info = { };
45         alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
46         alloc_info.commandPool = handle_cast<::VkCommandPool>(current_pool->pool);
47         alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
48         alloc_info.commandBufferCount = 1;
49
50         vk.AllocateCommandBuffers(alloc_info, &current_buffer);
51
52         VkCommandBufferBeginInfo begin_info = { };
53         begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
54         begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
55
56         vk.BeginCommandBuffer(current_buffer, begin_info);
57 }
58
59 void VulkanCommands::begin_render_pass(bool clear, const ClearValue *clear_values)
60 {
61         framebuffer = pipeline_state->get_framebuffer();
62         if(!framebuffer)
63                 throw invalid_operation("VulkanCommands::begin_render_pass");
64
65         const VulkanFunctions &vk = device.get_functions();
66
67         if(!current_buffer)
68                 begin_buffer();
69
70         device.get_transfer_queue().dispatch_transfers(current_buffer);
71
72         bool to_present = false;
73         unsigned n_attachments = framebuffer->get_format().size();
74         for(unsigned i=0; i<n_attachments; ++i)
75                 if(dynamic_cast<const SwapChainTexture *>(framebuffer->VulkanFramebuffer::get_attachment(i)))
76                         to_present = true;
77         VkRenderPass render_pass = device.get_pipeline_cache().get_render_pass(framebuffer->get_format(), clear, !clear_values, to_present);
78
79         framebuffer->refresh();
80
81         VkRenderPassBeginInfo begin_info = { };
82         begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
83         begin_info.renderPass = handle_cast<::VkRenderPass>(render_pass);
84         begin_info.framebuffer = handle_cast<::VkFramebuffer>(framebuffer->handle);
85
86         viewport = pipeline_state->get_viewport();
87         if(viewport)
88         {
89                 begin_info.renderArea.offset.x = viewport->left;
90                 begin_info.renderArea.offset.y = viewport->bottom;
91                 begin_info.renderArea.extent.width = viewport->width;
92                 begin_info.renderArea.extent.height = viewport->height;
93         }
94         else
95         {
96                 begin_info.renderArea.extent.width = framebuffer->get_width();
97                 begin_info.renderArea.extent.height = framebuffer->get_height();
98         }
99
100         VkClearValue vk_clear_values[7];
101         if(clear_values)
102         {
103                 unsigned i = 0;
104                 for(FrameAttachment a: framebuffer->get_format())
105                 {
106                         if(get_attach_point(a)==get_attach_point(DEPTH_ATTACHMENT))
107                                 vk_clear_values[i].depthStencil.depth = clear_values[i].depth_stencil.depth;
108                         else if(get_attach_point(a)==get_attach_point(STENCIL_ATTACHMENT))
109                                 vk_clear_values[i].depthStencil.stencil = clear_values[i].depth_stencil.stencil;
110                         else
111                         {
112                                 vk_clear_values[i].color.float32[0] = clear_values[i].color.r;
113                                 vk_clear_values[i].color.float32[1] = clear_values[i].color.g;
114                                 vk_clear_values[i].color.float32[2] = clear_values[i].color.b;
115                                 vk_clear_values[i].color.float32[3] = clear_values[i].color.a;
116                         }
117                         ++i;
118                 }
119
120                 begin_info.clearValueCount = framebuffer->get_format().size();
121                 begin_info.pClearValues = vk_clear_values;
122         }
123
124         vk.CmdBeginRenderPass(current_buffer, begin_info, VK_SUBPASS_CONTENTS_INLINE);
125 }
126
127 void VulkanCommands::end_render_pass()
128 {
129         const VulkanFunctions &vk = device.get_functions();
130
131         vk.CmdEndRenderPass(current_buffer);
132         framebuffer = 0;
133         viewport = 0;
134 }
135
136 void VulkanCommands::begin_frame(unsigned index)
137 {
138         const VulkanFunctions &vk = device.get_functions();
139
140         unsigned pool_index = index%device.get_n_frames_in_flight();
141         if(pool_index>=command_pools.size())
142         {
143                 command_pools.reserve(pool_index+1);
144                 for(unsigned i=command_pools.size(); i<pool_index+1; ++i)
145                         command_pools.emplace_back(device);
146         }
147
148         current_pool = &command_pools[pool_index];
149         if(current_pool->in_use)
150         {
151                 current_pool->fence.wait();
152                 vk.ResetCommandPool(current_pool->pool, 0);
153                 current_pool->in_use = false;
154         }
155 }
156
157 void VulkanCommands::submit_frame(Semaphore *wait_sem, Semaphore *signal_sem)
158 {
159         if(!current_buffer)
160                 return;
161
162         const VulkanFunctions &vk = device.get_functions();
163         ::VkSemaphore vk_wait_sem = (wait_sem ? handle_cast<::VkSemaphore>(wait_sem->handle) : 0);
164         ::VkSemaphore vk_signal_sem = (signal_sem ? handle_cast<::VkSemaphore>(signal_sem->handle) : 0);
165         VkPipelineStageFlags wait_stages = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
166
167         if(framebuffer)
168                 end_render_pass();
169
170         vk.EndCommandBuffer(current_buffer);
171
172         VkSubmitInfo submit_info = { };
173         submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
174         submit_info.waitSemaphoreCount = (wait_sem ? 1 : 0);
175         submit_info.pWaitSemaphores = &vk_wait_sem;
176         submit_info.pWaitDstStageMask = &wait_stages;
177         submit_info.commandBufferCount = 1;
178         submit_info.pCommandBuffers = handle_cast<::VkCommandBuffer *>(&current_buffer);
179         submit_info.signalSemaphoreCount = (signal_sem ? 1 : 0);
180         submit_info.pSignalSemaphores = &vk_signal_sem;
181
182         vk.QueueSubmit(1, &submit_info, current_pool->fence.handle);
183
184         current_buffer = 0;
185 }
186
187 void VulkanCommands::use_pipeline(const PipelineState *ps)
188 {
189         if(!pipeline_state || !ps || ps->get_framebuffer()!=framebuffer || ps->get_viewport()!=viewport)
190                 if(framebuffer)
191                         end_render_pass();
192
193         pipeline_state = ps;
194         if(pipeline_state)
195                 pipeline_state->refresh();
196 }
197
198 void VulkanCommands::clear(const ClearValue *values)
199 {
200         if(framebuffer)
201                 throw invalid_operation("VulkanCommands::clear");
202
203         begin_render_pass(true, values);
204 }
205
206 void VulkanCommands::draw(const Batch &batch)
207 {
208         draw_instanced(batch, 1);
209 }
210
211 void VulkanCommands::draw_instanced(const Batch &batch, unsigned count)
212 {
213         if(!pipeline_state)
214                 throw invalid_operation("VulkanCommands::draw_instanced");
215
216         const VulkanFunctions &vk = device.get_functions();
217
218         if(!framebuffer)
219                  begin_render_pass(false, 0);
220
221         pipeline_state->apply(current_buffer);
222         unsigned first_index = batch.get_offset()/batch.get_index_size();
223         vk.CmdDrawIndexed(current_buffer, batch.size(), count, first_index, 0, 0);
224 }
225
226 void VulkanCommands::resolve_multisample(Framebuffer &)
227 {
228         throw logic_error("VulkanCommands::resolve_multisample is unimplemented");
229 }
230
231 void VulkanCommands::begin_query(const QueryPool &, unsigned)
232 {
233         throw logic_error("VulkanCommands::begin_query is unimplemented");
234 }
235
236 void VulkanCommands::end_query(const QueryPool &, unsigned)
237 {
238         throw logic_error("VulkanCommands::end_query is unimplemented");
239 }
240
241
242 VulkanCommands::CommandPool::CommandPool(Device &d):
243         device(d),
244         fence(true)
245 {
246         const VulkanFunctions &vk = device.get_functions();
247
248         VkCommandPoolCreateInfo pool_info = { };
249         pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
250         pool_info.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
251         pool_info.queueFamilyIndex = device.get_context().get_private().graphics_queue_family;
252
253         vk.CreateCommandPool(pool_info, pool);
254 }
255
256 VulkanCommands::CommandPool::CommandPool(CommandPool &&other):
257         device(other.device),
258         pool(other.pool),
259         fence(move(other.fence)),
260         in_use(other.in_use)
261 {
262         other.pool = 0;
263 }
264
265 VulkanCommands::CommandPool::~CommandPool()
266 {
267         const VulkanFunctions &vk = device.get_functions();
268
269         if(pool)
270                 vk.DestroyCommandPool(pool);
271 }
272
273 } // namespace GL
274 } // namespace Msp