1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2015 The Khronos Group Inc.
6 * Copyright (c) 2015 Intel Corporation
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 *
20 *//*!
21 * \file
22 * \brief CreateInfo utilities
23 *//*--------------------------------------------------------------------*/
24
25 #include "vktDrawCreateInfoUtil.hpp"
26
27 #include "vkImageUtil.hpp"
28
29 namespace vkt
30 {
31 namespace Draw
32 {
33
ImageSubresourceRange(vk::VkImageAspectFlags _aspectMask,deUint32 _baseMipLevel,deUint32 _levelCount,deUint32 _baseArrayLayer,deUint32 _layerCount)34 ImageSubresourceRange::ImageSubresourceRange (vk::VkImageAspectFlags _aspectMask,
35 deUint32 _baseMipLevel,
36 deUint32 _levelCount,
37 deUint32 _baseArrayLayer,
38 deUint32 _layerCount)
39 {
40 aspectMask = _aspectMask;
41 baseMipLevel = _baseMipLevel;
42 levelCount = _levelCount;
43 baseArrayLayer = _baseArrayLayer;
44 layerCount = _layerCount;
45 }
46
ComponentMapping(vk::VkComponentSwizzle _r,vk::VkComponentSwizzle _g,vk::VkComponentSwizzle _b,vk::VkComponentSwizzle _a)47 ComponentMapping::ComponentMapping (vk::VkComponentSwizzle _r,
48 vk::VkComponentSwizzle _g,
49 vk::VkComponentSwizzle _b,
50 vk::VkComponentSwizzle _a)
51 {
52 r = _r;
53 g = _g;
54 b = _b;
55 a = _a;
56 }
57
ImageViewCreateInfo(vk::VkImage _image,vk::VkImageViewType _viewType,vk::VkFormat _format,const vk::VkImageSubresourceRange & _subresourceRange,const vk::VkComponentMapping & _components,vk::VkImageViewCreateFlags _flags)58 ImageViewCreateInfo::ImageViewCreateInfo (vk::VkImage _image,
59 vk::VkImageViewType _viewType,
60 vk::VkFormat _format,
61 const vk::VkImageSubresourceRange& _subresourceRange,
62 const vk::VkComponentMapping& _components,
63 vk::VkImageViewCreateFlags _flags)
64 {
65 sType = vk::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
66 pNext = DE_NULL;
67 flags = 0u;
68 image = _image;
69 viewType = _viewType;
70 format = _format;
71 components.r = _components.r;
72 components.g = _components.g;
73 components.b = _components.b;
74 components.a = _components.a;
75 subresourceRange = _subresourceRange;
76 flags = _flags;
77 }
78
ImageViewCreateInfo(vk::VkImage _image,vk::VkImageViewType _viewType,vk::VkFormat _format,const vk::VkComponentMapping & _components,vk::VkImageViewCreateFlags _flags)79 ImageViewCreateInfo::ImageViewCreateInfo (vk::VkImage _image,
80 vk::VkImageViewType _viewType,
81 vk::VkFormat _format,
82 const vk::VkComponentMapping& _components,
83 vk::VkImageViewCreateFlags _flags)
84 {
85 sType = vk::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
86 pNext = DE_NULL;
87 flags = 0u;
88 image = _image;
89 viewType = _viewType;
90 format = _format;
91 components.r = _components.r;
92 components.g = _components.g;
93 components.b = _components.b;
94 components.a = _components.a;
95
96 vk::VkImageAspectFlags aspectFlags;
97 const tcu::TextureFormat tcuFormat = vk::mapVkFormat(_format);
98
99 switch (tcuFormat.order)
100 {
101 case tcu::TextureFormat::D:
102 aspectFlags = vk::VK_IMAGE_ASPECT_DEPTH_BIT;
103 break;
104 case tcu::TextureFormat::S:
105 aspectFlags = vk::VK_IMAGE_ASPECT_STENCIL_BIT;
106 break;
107 case tcu::TextureFormat::DS:
108 aspectFlags = vk::VK_IMAGE_ASPECT_STENCIL_BIT | vk::VK_IMAGE_ASPECT_DEPTH_BIT;
109 break;
110 default:
111 aspectFlags = vk::VK_IMAGE_ASPECT_COLOR_BIT;
112 break;
113 }
114
115 subresourceRange = ImageSubresourceRange(aspectFlags);
116 flags = _flags;
117 }
118
BufferViewCreateInfo(vk::VkBuffer _buffer,vk::VkFormat _format,vk::VkDeviceSize _offset,vk::VkDeviceSize _range)119 BufferViewCreateInfo::BufferViewCreateInfo (vk::VkBuffer _buffer,
120 vk::VkFormat _format,
121 vk::VkDeviceSize _offset,
122 vk::VkDeviceSize _range)
123 {
124 sType = vk::VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
125 pNext = DE_NULL;
126
127 flags = 0;
128 buffer = _buffer;
129 format = _format;
130 offset = _offset;
131 range = _range;
132 }
133
BufferCreateInfo(vk::VkDeviceSize _size,vk::VkBufferUsageFlags _usage,vk::VkSharingMode _sharingMode,deUint32 _queueFamilyIndexCount,const deUint32 * _pQueueFamilyIndices,vk::VkBufferCreateFlags _flags)134 BufferCreateInfo::BufferCreateInfo (vk::VkDeviceSize _size,
135 vk::VkBufferUsageFlags _usage,
136 vk::VkSharingMode _sharingMode,
137 deUint32 _queueFamilyIndexCount,
138 const deUint32* _pQueueFamilyIndices,
139 vk::VkBufferCreateFlags _flags)
140 {
141 sType = vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
142 pNext = DE_NULL;
143 size = _size;
144 usage = _usage;
145 flags = _flags;
146 sharingMode = _sharingMode;
147 queueFamilyIndexCount = _queueFamilyIndexCount;
148
149 if (_queueFamilyIndexCount)
150 {
151 m_queueFamilyIndices = std::vector<deUint32>(
152 _pQueueFamilyIndices, _pQueueFamilyIndices + _queueFamilyIndexCount);
153 pQueueFamilyIndices = &m_queueFamilyIndices[0];
154 }
155 else
156 {
157 pQueueFamilyIndices = _pQueueFamilyIndices;
158 }
159 }
160
BufferCreateInfo(const BufferCreateInfo & other)161 BufferCreateInfo::BufferCreateInfo (const BufferCreateInfo &other)
162 {
163 sType = other.sType;
164 pNext = other.pNext;
165 size = other.size;
166 usage = other.usage;
167 flags = other.flags;
168 sharingMode = other.sharingMode;
169 queueFamilyIndexCount = other.queueFamilyIndexCount;
170
171 m_queueFamilyIndices = other.m_queueFamilyIndices;
172 DE_ASSERT(m_queueFamilyIndices.size() == queueFamilyIndexCount);
173
174 if (m_queueFamilyIndices.size())
175 {
176 pQueueFamilyIndices = &m_queueFamilyIndices[0];
177 }
178 else
179 {
180 pQueueFamilyIndices = DE_NULL;
181 }
182 }
183
operator =(const BufferCreateInfo & other)184 BufferCreateInfo & BufferCreateInfo::operator= (const BufferCreateInfo &other)
185 {
186 sType = other.sType;
187 pNext = other.pNext;
188 size = other.size;
189 usage = other.usage;
190 flags = other.flags;
191 sharingMode = other.sharingMode;
192 queueFamilyIndexCount = other.queueFamilyIndexCount;
193
194 m_queueFamilyIndices = other.m_queueFamilyIndices;
195
196 DE_ASSERT(m_queueFamilyIndices.size() == queueFamilyIndexCount);
197
198 if (m_queueFamilyIndices.size())
199 {
200 pQueueFamilyIndices = &m_queueFamilyIndices[0];
201 }
202 else
203 {
204 pQueueFamilyIndices = DE_NULL;
205 }
206
207 return *this;
208 }
209
ImageCreateInfo(vk::VkImageType _imageType,vk::VkFormat _format,vk::VkExtent3D _extent,deUint32 _mipLevels,deUint32 _arrayLayers,vk::VkSampleCountFlagBits _samples,vk::VkImageTiling _tiling,vk::VkImageUsageFlags _usage,vk::VkSharingMode _sharingMode,deUint32 _queueFamilyIndexCount,const deUint32 * _pQueueFamilyIndices,vk::VkImageCreateFlags _flags,vk::VkImageLayout _initialLayout)210 ImageCreateInfo::ImageCreateInfo (vk::VkImageType _imageType,
211 vk::VkFormat _format,
212 vk::VkExtent3D _extent,
213 deUint32 _mipLevels,
214 deUint32 _arrayLayers,
215 vk::VkSampleCountFlagBits _samples,
216 vk::VkImageTiling _tiling,
217 vk::VkImageUsageFlags _usage,
218 vk::VkSharingMode _sharingMode,
219 deUint32 _queueFamilyIndexCount,
220 const deUint32* _pQueueFamilyIndices,
221 vk::VkImageCreateFlags _flags,
222 vk::VkImageLayout _initialLayout)
223 {
224 if (_queueFamilyIndexCount)
225 {
226 m_queueFamilyIndices = std::vector<deUint32>(_pQueueFamilyIndices, _pQueueFamilyIndices + _queueFamilyIndexCount);
227 }
228
229 sType = vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
230 pNext = DE_NULL;
231 flags = _flags;
232 imageType = _imageType;
233 format = _format;
234 extent = _extent;
235 mipLevels = _mipLevels;
236 arrayLayers = _arrayLayers;
237 samples = _samples;
238 tiling = _tiling;
239 usage = _usage;
240 sharingMode = _sharingMode;
241 queueFamilyIndexCount = _queueFamilyIndexCount;
242
243 if (m_queueFamilyIndices.size())
244 {
245 pQueueFamilyIndices = &m_queueFamilyIndices[0];
246 }
247 else
248 {
249 pQueueFamilyIndices = DE_NULL;
250 }
251 initialLayout = _initialLayout;
252 }
253
FramebufferCreateInfo(vk::VkRenderPass _renderPass,const std::vector<vk::VkImageView> & atachments,deUint32 _width,deUint32 _height,deUint32 _layers)254 FramebufferCreateInfo::FramebufferCreateInfo (vk::VkRenderPass _renderPass,
255 const std::vector<vk::VkImageView>& atachments,
256 deUint32 _width,
257 deUint32 _height,
258 deUint32 _layers)
259 {
260 sType = vk::VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
261 pNext = DE_NULL;
262 flags = 0u;
263
264 renderPass = _renderPass;
265 attachmentCount = static_cast<deUint32>(atachments.size());
266
267 if (attachmentCount)
268 {
269 pAttachments = const_cast<vk::VkImageView *>(&atachments[0]);
270 }
271
272 width = _width;
273 height = _height;
274 layers = _layers;
275 }
276
RenderPassCreateInfo(const std::vector<vk::VkAttachmentDescription> & attachments,const std::vector<vk::VkSubpassDescription> & subpasses,const std::vector<vk::VkSubpassDependency> & dependiences)277 RenderPassCreateInfo::RenderPassCreateInfo (const std::vector<vk::VkAttachmentDescription>& attachments,
278 const std::vector<vk::VkSubpassDescription>& subpasses,
279 const std::vector<vk::VkSubpassDependency>& dependiences)
280
281 : m_attachments (attachments.begin(), attachments.end())
282 , m_subpasses (subpasses.begin(), subpasses.end())
283 , m_dependiences (dependiences.begin(), dependiences.end())
284 , m_attachmentsStructs (m_attachments.begin(), m_attachments.end())
285 , m_subpassesStructs (m_subpasses.begin(), m_subpasses.end())
286 , m_dependiencesStructs (m_dependiences.begin(), m_dependiences.end())
287 {
288 sType = vk::VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
289 pNext = DE_NULL;
290 flags = 0;
291
292 attachmentCount = static_cast<deUint32>(m_attachments.size());
293 pAttachments = &m_attachmentsStructs[0];
294 subpassCount = static_cast<deUint32>(m_subpasses.size());
295 pSubpasses = &m_subpassesStructs[0];
296 dependencyCount = static_cast<deUint32>(m_dependiences.size());
297 pDependencies = &m_dependiencesStructs[0];
298 }
299
RenderPassCreateInfo(deUint32 _attachmentCount,const vk::VkAttachmentDescription * _pAttachments,deUint32 _subpassCount,const vk::VkSubpassDescription * _pSubpasses,deUint32 _dependencyCount,const vk::VkSubpassDependency * _pDependiences)300 RenderPassCreateInfo::RenderPassCreateInfo (deUint32 _attachmentCount,
301 const vk::VkAttachmentDescription* _pAttachments,
302 deUint32 _subpassCount,
303 const vk::VkSubpassDescription* _pSubpasses,
304 deUint32 _dependencyCount,
305 const vk::VkSubpassDependency* _pDependiences)
306 {
307
308 m_attachments = std::vector<AttachmentDescription>(_pAttachments, _pAttachments + _attachmentCount);
309 m_subpasses = std::vector<SubpassDescription>(_pSubpasses, _pSubpasses + _subpassCount);
310 m_dependiences = std::vector<SubpassDependency>(_pDependiences, _pDependiences + _dependencyCount);
311
312 m_attachmentsStructs = std::vector<vk::VkAttachmentDescription> (m_attachments.begin(), m_attachments.end());
313 m_subpassesStructs = std::vector<vk::VkSubpassDescription> (m_subpasses.begin(), m_subpasses.end());
314 m_dependiencesStructs = std::vector<vk::VkSubpassDependency> (m_dependiences.begin(), m_dependiences.end());
315
316 sType = vk::VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
317 pNext = DE_NULL;
318 flags = 0;
319
320 attachmentCount = static_cast<deUint32>(m_attachments.size());
321
322 if (attachmentCount) {
323 pAttachments = &m_attachmentsStructs[0];
324 }
325 else
326 {
327 pAttachments = DE_NULL;
328 }
329
330 subpassCount = static_cast<deUint32>(m_subpasses.size());
331
332 if (subpassCount) {
333 pSubpasses = &m_subpassesStructs[0];
334 }
335 else
336 {
337 pSubpasses = DE_NULL;
338 }
339
340 dependencyCount = static_cast<deUint32>(m_dependiences.size());
341
342 if (dependencyCount) {
343 pDependencies = &m_dependiencesStructs[0];
344 }
345 else
346 {
347 pDependencies = DE_NULL;
348 }
349 }
350
351 void
addAttachment(vk::VkAttachmentDescription attachment)352 RenderPassCreateInfo::addAttachment (vk::VkAttachmentDescription attachment)
353 {
354
355 m_attachments.push_back(attachment);
356 m_attachmentsStructs = std::vector<vk::VkAttachmentDescription>(m_attachments.begin(), m_attachments.end());
357 attachmentCount = static_cast<deUint32>(m_attachments.size());
358 pAttachments = &m_attachmentsStructs[0];
359 }
360
361 void
addSubpass(vk::VkSubpassDescription subpass)362 RenderPassCreateInfo::addSubpass (vk::VkSubpassDescription subpass)
363 {
364
365 m_subpasses.push_back(subpass);
366 m_subpassesStructs = std::vector<vk::VkSubpassDescription>(m_subpasses.begin(), m_subpasses.end());
367 subpassCount = static_cast<deUint32>(m_subpasses.size());
368 pSubpasses = &m_subpassesStructs[0];
369 }
370
371 void
addDependency(vk::VkSubpassDependency dependency)372 RenderPassCreateInfo::addDependency (vk::VkSubpassDependency dependency)
373 {
374
375 m_dependiences.push_back(dependency);
376 m_dependiencesStructs = std::vector<vk::VkSubpassDependency>(m_dependiences.begin(), m_dependiences.end());
377
378 dependencyCount = static_cast<deUint32>(m_dependiences.size());
379 pDependencies = &m_dependiencesStructs[0];
380 }
381
RenderPassBeginInfo(vk::VkRenderPass _renderPass,vk::VkFramebuffer _framebuffer,vk::VkRect2D _renderArea,const std::vector<vk::VkClearValue> & _clearValues)382 RenderPassBeginInfo::RenderPassBeginInfo (vk::VkRenderPass _renderPass,
383 vk::VkFramebuffer _framebuffer,
384 vk::VkRect2D _renderArea,
385 const std::vector<vk::VkClearValue>& _clearValues)
386 {
387
388 m_clearValues = _clearValues;
389
390 sType = vk::VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
391 pNext = DE_NULL;
392 renderPass = _renderPass;
393 framebuffer = _framebuffer;
394 renderArea = _renderArea;
395 clearValueCount = static_cast<deUint32>(m_clearValues.size());
396 pClearValues = m_clearValues.size() ? &m_clearValues[0] : DE_NULL;
397 }
398
CmdPoolCreateInfo(deUint32 _queueFamilyIndex,unsigned int _flags)399 CmdPoolCreateInfo::CmdPoolCreateInfo (deUint32 _queueFamilyIndex, unsigned int _flags)
400 {
401 sType = vk::VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
402 pNext = DE_NULL;
403
404 queueFamilyIndex = _queueFamilyIndex;
405 flags = _flags;
406 }
407
AttachmentDescription(vk::VkFormat _format,vk::VkSampleCountFlagBits _samples,vk::VkAttachmentLoadOp _loadOp,vk::VkAttachmentStoreOp _storeOp,vk::VkAttachmentLoadOp _stencilLoadOp,vk::VkAttachmentStoreOp _stencilStoreOp,vk::VkImageLayout _initialLayout,vk::VkImageLayout _finalLayout)408 AttachmentDescription::AttachmentDescription (vk::VkFormat _format,
409 vk::VkSampleCountFlagBits _samples,
410 vk::VkAttachmentLoadOp _loadOp,
411 vk::VkAttachmentStoreOp _storeOp,
412 vk::VkAttachmentLoadOp _stencilLoadOp,
413 vk::VkAttachmentStoreOp _stencilStoreOp,
414 vk::VkImageLayout _initialLayout,
415 vk::VkImageLayout _finalLayout)
416 {
417 flags = 0;
418 format = _format;
419 samples = _samples;
420 loadOp = _loadOp;
421 storeOp = _storeOp;
422 stencilLoadOp = _stencilLoadOp;
423 stencilStoreOp = _stencilStoreOp;
424 initialLayout = _initialLayout;
425 finalLayout = _finalLayout;
426 }
427
AttachmentDescription(const vk::VkAttachmentDescription & rhs)428 AttachmentDescription::AttachmentDescription (const vk::VkAttachmentDescription& rhs)
429 {
430 flags = rhs.flags;
431 format = rhs.format;
432 samples = rhs.samples;
433 loadOp = rhs.loadOp;
434 storeOp = rhs.storeOp;
435 stencilLoadOp = rhs.stencilLoadOp;
436 stencilStoreOp = rhs.stencilStoreOp;
437 initialLayout = rhs.initialLayout;
438 finalLayout = rhs.finalLayout;
439 }
440
AttachmentReference(deUint32 _attachment,vk::VkImageLayout _layout)441 AttachmentReference::AttachmentReference (deUint32 _attachment, vk::VkImageLayout _layout)
442 {
443 attachment = _attachment;
444 layout = _layout;
445 }
446
AttachmentReference(void)447 AttachmentReference::AttachmentReference (void)
448 {
449 attachment = VK_ATTACHMENT_UNUSED;
450 layout = vk::VK_IMAGE_LAYOUT_UNDEFINED;
451 }
452
SubpassDescription(vk::VkPipelineBindPoint _pipelineBindPoint,vk::VkSubpassDescriptionFlags _flags,deUint32 _inputAttachmentCount,const vk::VkAttachmentReference * _inputAttachments,deUint32 _colorAttachmentCount,const vk::VkAttachmentReference * _colorAttachments,const vk::VkAttachmentReference * _resolveAttachments,vk::VkAttachmentReference depthStencilAttachment,deUint32 _preserveAttachmentCount,const deUint32 * _preserveAttachments)453 SubpassDescription::SubpassDescription (vk::VkPipelineBindPoint _pipelineBindPoint,
454 vk::VkSubpassDescriptionFlags _flags,
455 deUint32 _inputAttachmentCount,
456 const vk::VkAttachmentReference* _inputAttachments,
457 deUint32 _colorAttachmentCount,
458 const vk::VkAttachmentReference* _colorAttachments,
459 const vk::VkAttachmentReference* _resolveAttachments,
460 vk::VkAttachmentReference depthStencilAttachment,
461 deUint32 _preserveAttachmentCount,
462 const deUint32* _preserveAttachments)
463 {
464 m_inputAttachments = std::vector<vk::VkAttachmentReference>(_inputAttachments, _inputAttachments + _inputAttachmentCount);
465 m_colorAttachments = std::vector<vk::VkAttachmentReference>(_colorAttachments, _colorAttachments + _colorAttachmentCount);
466
467 if (_resolveAttachments)
468 m_resolveAttachments = std::vector<vk::VkAttachmentReference>(_resolveAttachments, _resolveAttachments + _colorAttachmentCount);
469
470 m_preserveAttachments = std::vector<deUint32>(_preserveAttachments, _preserveAttachments + _preserveAttachmentCount);
471
472 m_depthStencilAttachment = depthStencilAttachment;
473
474 flags = _flags;
475 pipelineBindPoint = _pipelineBindPoint;
476 inputAttachmentCount = _inputAttachmentCount;
477 pInputAttachments = DE_NULL;
478 colorAttachmentCount = _colorAttachmentCount;
479 pColorAttachments = DE_NULL;
480 pResolveAttachments = DE_NULL;
481 pDepthStencilAttachment = &m_depthStencilAttachment;
482 pPreserveAttachments = DE_NULL;
483 preserveAttachmentCount = _preserveAttachmentCount;
484
485 if (!m_inputAttachments.empty())
486 pInputAttachments = &m_inputAttachments[0];
487
488 if (!m_colorAttachments.empty())
489 pColorAttachments = &m_colorAttachments[0];
490
491 if (!m_resolveAttachments.empty())
492 pResolveAttachments = &m_resolveAttachments[0];
493
494 if (!m_preserveAttachments.empty())
495 pPreserveAttachments = &m_preserveAttachments[0];
496 }
497
SubpassDescription(const vk::VkSubpassDescription & rhs)498 SubpassDescription::SubpassDescription (const vk::VkSubpassDescription& rhs)
499 {
500 *static_cast<vk::VkSubpassDescription*>(this) = rhs;
501
502 m_inputAttachments = std::vector<vk::VkAttachmentReference>(
503 rhs.pInputAttachments, rhs.pInputAttachments + rhs.inputAttachmentCount);
504
505 m_colorAttachments = std::vector<vk::VkAttachmentReference>(
506 rhs.pColorAttachments, rhs.pColorAttachments + rhs.colorAttachmentCount);
507
508 if (rhs.pResolveAttachments)
509 m_resolveAttachments = std::vector<vk::VkAttachmentReference>(
510 rhs.pResolveAttachments, rhs.pResolveAttachments + rhs.colorAttachmentCount);
511
512 m_preserveAttachments = std::vector<deUint32>(
513 rhs.pPreserveAttachments, rhs.pPreserveAttachments + rhs.preserveAttachmentCount);
514
515 if (rhs.pDepthStencilAttachment)
516 m_depthStencilAttachment = *rhs.pDepthStencilAttachment;
517
518 if (!m_inputAttachments.empty())
519 pInputAttachments = &m_inputAttachments[0];
520
521 if (!m_colorAttachments.empty())
522 pColorAttachments = &m_colorAttachments[0];
523
524 if (!m_resolveAttachments.empty())
525 pResolveAttachments = &m_resolveAttachments[0];
526
527 pDepthStencilAttachment = &m_depthStencilAttachment;
528
529 if (!m_preserveAttachments.empty())
530 pPreserveAttachments = &m_preserveAttachments[0];
531 }
532
SubpassDescription(const SubpassDescription & rhs)533 SubpassDescription::SubpassDescription (const SubpassDescription& rhs) {
534 *this = rhs;
535 }
536
operator =(const SubpassDescription & rhs)537 SubpassDescription& SubpassDescription::operator= (const SubpassDescription& rhs)
538 {
539 *static_cast<vk::VkSubpassDescription*>(this) = rhs;
540
541 m_inputAttachments = rhs.m_inputAttachments;
542 m_colorAttachments = rhs.m_colorAttachments;
543 m_resolveAttachments = rhs.m_resolveAttachments;
544 m_preserveAttachments = rhs.m_preserveAttachments;
545 m_depthStencilAttachment = rhs.m_depthStencilAttachment;
546
547 if (!m_inputAttachments.empty())
548 pInputAttachments = &m_inputAttachments[0];
549
550 if (!m_colorAttachments.empty())
551 pColorAttachments = &m_colorAttachments[0];
552
553 if (!m_resolveAttachments.empty())
554 pResolveAttachments = &m_resolveAttachments[0];
555
556 pDepthStencilAttachment = &m_depthStencilAttachment;
557
558 if (!m_preserveAttachments.empty())
559 pPreserveAttachments = &m_preserveAttachments[0];
560
561 return *this;
562 }
563
SubpassDependency(deUint32 _srcSubpass,deUint32 _dstSubpass,vk::VkPipelineStageFlags _srcStageMask,vk::VkPipelineStageFlags _dstStageMask,vk::VkAccessFlags _srcAccessMask,vk::VkAccessFlags _dstAccessMask,vk::VkDependencyFlags _dependencyFlags)564 SubpassDependency::SubpassDependency (deUint32 _srcSubpass,
565 deUint32 _dstSubpass,
566 vk::VkPipelineStageFlags _srcStageMask,
567 vk::VkPipelineStageFlags _dstStageMask,
568 vk::VkAccessFlags _srcAccessMask,
569 vk::VkAccessFlags _dstAccessMask,
570 vk::VkDependencyFlags _dependencyFlags)
571 {
572 srcSubpass = _srcSubpass;
573 dstSubpass = _dstSubpass;
574 srcStageMask = _srcStageMask;
575 dstStageMask = _dstStageMask;
576 srcAccessMask = _srcAccessMask;
577 dstAccessMask = _dstAccessMask;
578 dependencyFlags = _dependencyFlags;
579 }
580
SubpassDependency(const vk::VkSubpassDependency & rhs)581 SubpassDependency::SubpassDependency (const vk::VkSubpassDependency& rhs)
582 {
583 srcSubpass = rhs.srcSubpass;
584 dstSubpass = rhs.dstSubpass;
585 srcStageMask = rhs.srcStageMask;
586 dstStageMask = rhs.dstStageMask;
587 srcAccessMask = rhs.srcAccessMask;
588 dstAccessMask = rhs.dstAccessMask;
589 dependencyFlags = rhs.dependencyFlags;
590 }
591
CmdBufferBeginInfo(vk::VkCommandBufferUsageFlags _flags)592 CmdBufferBeginInfo::CmdBufferBeginInfo (vk::VkCommandBufferUsageFlags _flags)
593 {
594 sType = vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
595 pNext = DE_NULL;
596 flags = _flags;
597 pInheritanceInfo = DE_NULL;
598 }
599
DescriptorPoolCreateInfo(const std::vector<vk::VkDescriptorPoolSize> & poolSizeCounts,vk::VkDescriptorPoolCreateFlags _flags,deUint32 _maxSets)600 DescriptorPoolCreateInfo::DescriptorPoolCreateInfo (const std::vector<vk::VkDescriptorPoolSize>& poolSizeCounts,
601 vk::VkDescriptorPoolCreateFlags _flags,
602 deUint32 _maxSets)
603 : m_poolSizeCounts(poolSizeCounts)
604 {
605 sType = vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
606 pNext = DE_NULL;
607 flags = _flags;
608 maxSets = _maxSets;
609 poolSizeCount = static_cast<deUint32>(m_poolSizeCounts.size());
610 pPoolSizes = &m_poolSizeCounts[0];
611 }
612
addDescriptors(vk::VkDescriptorType type,deUint32 count)613 DescriptorPoolCreateInfo& DescriptorPoolCreateInfo::addDescriptors (vk::VkDescriptorType type, deUint32 count)
614 {
615 vk::VkDescriptorPoolSize descriptorTypeCount = { type, count };
616 m_poolSizeCounts.push_back(descriptorTypeCount);
617
618 poolSizeCount = static_cast<deUint32>(m_poolSizeCounts.size());
619 pPoolSizes = &m_poolSizeCounts[0];
620
621 return *this;
622 }
623
DescriptorSetLayoutCreateInfo(deUint32 _bindingCount,const vk::VkDescriptorSetLayoutBinding * _pBindings)624 DescriptorSetLayoutCreateInfo::DescriptorSetLayoutCreateInfo (deUint32 _bindingCount, const vk::VkDescriptorSetLayoutBinding* _pBindings)
625 {
626 sType = vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
627 pNext = DE_NULL;
628 flags = 0;
629 bindingCount = _bindingCount;
630 pBindings = _pBindings;
631 }
632
PipelineLayoutCreateInfo(deUint32 _descriptorSetCount,const vk::VkDescriptorSetLayout * _pSetLayouts,deUint32 _pushConstantRangeCount,const vk::VkPushConstantRange * _pPushConstantRanges)633 PipelineLayoutCreateInfo::PipelineLayoutCreateInfo (deUint32 _descriptorSetCount,
634 const vk::VkDescriptorSetLayout* _pSetLayouts,
635 deUint32 _pushConstantRangeCount,
636 const vk::VkPushConstantRange* _pPushConstantRanges)
637 : m_pushConstantRanges(_pPushConstantRanges, _pPushConstantRanges + _pushConstantRangeCount)
638 {
639 for (unsigned int i = 0; i < _descriptorSetCount; i++)
640 {
641 m_setLayouts.push_back(_pSetLayouts[i]);
642 }
643
644 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
645 pNext = DE_NULL;
646 flags = 0;
647 setLayoutCount = static_cast<deUint32>(m_setLayouts.size());
648 pSetLayouts = setLayoutCount > 0 ? &m_setLayouts[0] : DE_NULL;
649 pushConstantRangeCount = static_cast<deUint32>(m_pushConstantRanges.size());
650
651 if (m_pushConstantRanges.size()) {
652 pPushConstantRanges = &m_pushConstantRanges[0];
653 }
654 else
655 {
656 pPushConstantRanges = DE_NULL;
657 }
658 }
659
PipelineLayoutCreateInfo(const std::vector<vk::VkDescriptorSetLayout> & setLayouts,deUint32 _pushConstantRangeCount,const vk::VkPushConstantRange * _pPushConstantRanges)660 PipelineLayoutCreateInfo::PipelineLayoutCreateInfo (const std::vector<vk::VkDescriptorSetLayout>& setLayouts,
661 deUint32 _pushConstantRangeCount,
662 const vk::VkPushConstantRange* _pPushConstantRanges)
663 : m_setLayouts (setLayouts)
664 , m_pushConstantRanges (_pPushConstantRanges, _pPushConstantRanges + _pushConstantRangeCount)
665 {
666 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
667 pNext = DE_NULL;
668
669 flags = 0;
670 setLayoutCount = static_cast<deUint32>(m_setLayouts.size());
671
672 if (setLayoutCount)
673 {
674 pSetLayouts = &m_setLayouts[0];
675 }
676 else
677 {
678 pSetLayouts = DE_NULL;
679 }
680
681 pushConstantRangeCount = static_cast<deUint32>(m_pushConstantRanges.size());
682 if (pushConstantRangeCount) {
683 pPushConstantRanges = &m_pushConstantRanges[0];
684 }
685 else
686 {
687 pPushConstantRanges = DE_NULL;
688 }
689 }
690
PipelineShaderStage(vk::VkShaderModule _module,const char * _pName,vk::VkShaderStageFlagBits _stage)691 PipelineCreateInfo::PipelineShaderStage::PipelineShaderStage (vk::VkShaderModule _module, const char* _pName, vk::VkShaderStageFlagBits _stage)
692 {
693 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
694 pNext = DE_NULL;
695 flags = 0u;
696 stage = _stage;
697 module = _module;
698 pName = _pName;
699 pSpecializationInfo = DE_NULL;
700 }
701
VertexInputState(deUint32 _vertexBindingDescriptionCount,const vk::VkVertexInputBindingDescription * _pVertexBindingDescriptions,deUint32 _vertexAttributeDescriptionCount,const vk::VkVertexInputAttributeDescription * _pVertexAttributeDescriptions)702 PipelineCreateInfo::VertexInputState::VertexInputState (deUint32 _vertexBindingDescriptionCount,
703 const vk::VkVertexInputBindingDescription* _pVertexBindingDescriptions,
704 deUint32 _vertexAttributeDescriptionCount,
705 const vk::VkVertexInputAttributeDescription* _pVertexAttributeDescriptions)
706 {
707 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
708 pNext = DE_NULL;
709 flags = 0u;
710 vertexBindingDescriptionCount = _vertexBindingDescriptionCount;
711 pVertexBindingDescriptions = _pVertexBindingDescriptions;
712 vertexAttributeDescriptionCount = _vertexAttributeDescriptionCount;
713 pVertexAttributeDescriptions = _pVertexAttributeDescriptions;
714 }
715
addDivisors(deUint32 _vertexBindingDivisorCount,const vk::VkVertexInputBindingDivisorDescriptionEXT * _pVertexBindingDivisors)716 PipelineCreateInfo::VertexInputState& PipelineCreateInfo::VertexInputState::addDivisors (deUint32 _vertexBindingDivisorCount,
717 const vk::VkVertexInputBindingDivisorDescriptionEXT* _pVertexBindingDivisors)
718 {
719 m_divisorState.sType = vk::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT;
720 m_divisorState.vertexBindingDivisorCount = _vertexBindingDivisorCount;
721 m_divisorState.pVertexBindingDivisors = _pVertexBindingDivisors;
722
723 // Link it into the chainadd
724 m_divisorState.pNext = this->pNext;
725 pNext = &m_divisorState;
726
727 return *this;
728 }
729
InputAssemblerState(vk::VkPrimitiveTopology _topology,vk::VkBool32 _primitiveRestartEnable)730 PipelineCreateInfo::InputAssemblerState::InputAssemblerState (vk::VkPrimitiveTopology _topology,
731 vk::VkBool32 _primitiveRestartEnable)
732 {
733 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
734 pNext = DE_NULL;
735 flags = 0u;
736 topology = _topology;
737 primitiveRestartEnable = _primitiveRestartEnable;
738 }
739
TessellationState(deUint32 _patchControlPoints)740 PipelineCreateInfo::TessellationState::TessellationState (deUint32 _patchControlPoints)
741 {
742 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
743 pNext = DE_NULL;
744 flags = 0;
745 patchControlPoints = _patchControlPoints;
746 }
747
ViewportState(deUint32 _viewportCount,std::vector<vk::VkViewport> _viewports,std::vector<vk::VkRect2D> _scissors)748 PipelineCreateInfo::ViewportState::ViewportState (deUint32 _viewportCount,
749 std::vector<vk::VkViewport> _viewports,
750 std::vector<vk::VkRect2D> _scissors)
751 {
752 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
753 pNext = DE_NULL;
754 flags = 0u;
755 viewportCount = _viewportCount;
756 scissorCount = _viewportCount;
757
758 if (!_viewports.size())
759 {
760 m_viewports.resize(viewportCount);
761 deMemset(&m_viewports[0], 0, sizeof(m_viewports[0]) * m_viewports.size());
762 }
763 else
764 {
765 m_viewports = _viewports;
766 }
767
768 if (!_scissors.size())
769 {
770 m_scissors.resize(scissorCount);
771 deMemset(&m_scissors[0], 0, sizeof(m_scissors[0]) * m_scissors.size());
772 }
773 else
774 {
775 m_scissors = _scissors;
776 }
777
778 pViewports = &m_viewports[0];
779 pScissors = &m_scissors[0];
780 }
781
ViewportState(const ViewportState & other)782 PipelineCreateInfo::ViewportState::ViewportState (const ViewportState& other)
783 {
784 sType = other.sType;
785 pNext = other.pNext;
786 flags = other.flags;
787 viewportCount = other.viewportCount;
788 scissorCount = other.scissorCount;
789
790 m_viewports = std::vector<vk::VkViewport>(other.pViewports, other.pViewports + viewportCount);
791 m_scissors = std::vector<vk::VkRect2D>(other.pScissors, other.pScissors + scissorCount);
792
793 pViewports = &m_viewports[0];
794 pScissors = &m_scissors[0];
795 }
796
operator =(const ViewportState & other)797 PipelineCreateInfo::ViewportState& PipelineCreateInfo::ViewportState::operator= (const ViewportState& other)
798 {
799 sType = other.sType;
800 pNext = other.pNext;
801 flags = other.flags;
802 viewportCount = other.viewportCount;
803 scissorCount = other.scissorCount;
804
805 m_viewports = std::vector<vk::VkViewport>(other.pViewports, other.pViewports + scissorCount);
806 m_scissors = std::vector<vk::VkRect2D>(other.pScissors, other.pScissors + scissorCount);
807
808 pViewports = &m_viewports[0];
809 pScissors = &m_scissors[0];
810 return *this;
811 }
812
RasterizerState(vk::VkBool32 _depthClampEnable,vk::VkBool32 _rasterizerDiscardEnable,vk::VkPolygonMode _polygonMode,vk::VkCullModeFlags _cullMode,vk::VkFrontFace _frontFace,vk::VkBool32 _depthBiasEnable,float _depthBiasConstantFactor,float _depthBiasClamp,float _depthBiasSlopeFactor,float _lineWidth)813 PipelineCreateInfo::RasterizerState::RasterizerState (vk::VkBool32 _depthClampEnable,
814 vk::VkBool32 _rasterizerDiscardEnable,
815 vk::VkPolygonMode _polygonMode,
816 vk::VkCullModeFlags _cullMode,
817 vk::VkFrontFace _frontFace,
818 vk::VkBool32 _depthBiasEnable,
819 float _depthBiasConstantFactor,
820 float _depthBiasClamp,
821 float _depthBiasSlopeFactor,
822 float _lineWidth)
823 {
824 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
825 pNext = DE_NULL;
826 flags = 0u;
827 depthClampEnable = _depthClampEnable;
828 rasterizerDiscardEnable = _rasterizerDiscardEnable;
829 polygonMode = _polygonMode;
830 cullMode = _cullMode;
831 frontFace = _frontFace;
832
833 depthBiasEnable = _depthBiasEnable;
834 depthBiasConstantFactor = _depthBiasConstantFactor;
835 depthBiasClamp = _depthBiasClamp;
836 depthBiasSlopeFactor = _depthBiasSlopeFactor;
837 lineWidth = _lineWidth;
838 }
839
MultiSampleState(vk::VkSampleCountFlagBits _rasterizationSamples,vk::VkBool32 _sampleShadingEnable,float _minSampleShading,const std::vector<vk::VkSampleMask> & _sampleMask,bool _alphaToCoverageEnable,bool _alphaToOneEnable)840 PipelineCreateInfo::MultiSampleState::MultiSampleState (vk::VkSampleCountFlagBits _rasterizationSamples,
841 vk::VkBool32 _sampleShadingEnable,
842 float _minSampleShading,
843 const std::vector<vk::VkSampleMask>& _sampleMask,
844 bool _alphaToCoverageEnable,
845 bool _alphaToOneEnable)
846 : m_sampleMask(_sampleMask)
847 {
848 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
849 pNext = DE_NULL;
850 flags = 0u;
851 rasterizationSamples = _rasterizationSamples;
852 sampleShadingEnable = _sampleShadingEnable;
853 minSampleShading = _minSampleShading;
854 pSampleMask = &m_sampleMask[0];
855 alphaToCoverageEnable = _alphaToCoverageEnable;
856 alphaToOneEnable = _alphaToOneEnable;
857 }
858
MultiSampleState(const MultiSampleState & other)859 PipelineCreateInfo::MultiSampleState::MultiSampleState (const MultiSampleState& other)
860 {
861 sType = other.sType;
862 pNext = other.pNext;
863 flags = other.flags;
864 rasterizationSamples = other.rasterizationSamples;
865 sampleShadingEnable = other.sampleShadingEnable;
866 minSampleShading = other.minSampleShading;
867
868 const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + other.rasterizationSamples) / (sizeof(vk::VkSampleMask) * 8);
869
870 m_sampleMask = std::vector<vk::VkSampleMask>(other.pSampleMask, other.pSampleMask + sampleMaskArrayLen);
871 pSampleMask = &m_sampleMask[0];
872 }
873
operator =(const MultiSampleState & other)874 PipelineCreateInfo::MultiSampleState& PipelineCreateInfo::MultiSampleState::operator= (const MultiSampleState& other)
875 {
876 sType = other.sType;
877 pNext = other.pNext;
878 flags = other.flags;
879 rasterizationSamples = other.rasterizationSamples;
880 sampleShadingEnable = other.sampleShadingEnable;
881 minSampleShading = other.minSampleShading;
882
883 const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + other.rasterizationSamples) / (sizeof(vk::VkSampleMask) * 8);
884
885 m_sampleMask = std::vector<vk::VkSampleMask>(other.pSampleMask, other.pSampleMask + sampleMaskArrayLen);
886 pSampleMask = &m_sampleMask[0];
887
888 return *this;
889 }
890
ColorBlendState(const std::vector<vk::VkPipelineColorBlendAttachmentState> & _attachments,vk::VkBool32 _logicOpEnable,vk::VkLogicOp _logicOp)891 PipelineCreateInfo::ColorBlendState::ColorBlendState (const std::vector<vk::VkPipelineColorBlendAttachmentState>& _attachments,
892 vk::VkBool32 _logicOpEnable,
893 vk::VkLogicOp _logicOp)
894 : m_attachments(_attachments)
895 {
896 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
897 pNext = DE_NULL;
898 flags = 0u;
899 logicOpEnable = _logicOpEnable;
900 logicOp = _logicOp;
901 attachmentCount = static_cast<deUint32>(m_attachments.size());
902 pAttachments = &m_attachments[0];
903 deMemset(blendConstants, 0, sizeof(blendConstants));
904 }
905
ColorBlendState(deUint32 _attachmentCount,const vk::VkPipelineColorBlendAttachmentState * _attachments,vk::VkBool32 _logicOpEnable,vk::VkLogicOp _logicOp)906 PipelineCreateInfo::ColorBlendState::ColorBlendState (deUint32 _attachmentCount,
907 const vk::VkPipelineColorBlendAttachmentState* _attachments,
908 vk::VkBool32 _logicOpEnable,
909 vk::VkLogicOp _logicOp)
910 : m_attachments(_attachments, _attachments + _attachmentCount)
911 {
912 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
913 pNext = DE_NULL;
914 flags = 0;
915 logicOpEnable = _logicOpEnable;
916 logicOp = _logicOp;
917 attachmentCount = static_cast<deUint32>(m_attachments.size());
918 pAttachments = &m_attachments[0];
919 deMemset(blendConstants, 0, sizeof(blendConstants));
920 }
921
ColorBlendState(const vk::VkPipelineColorBlendStateCreateInfo & createInfo)922 PipelineCreateInfo::ColorBlendState::ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo& createInfo)
923 : m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount)
924 {
925 sType = createInfo.sType;
926 pNext = createInfo.pNext;
927 flags = createInfo.flags;
928 logicOpEnable = createInfo.logicOpEnable;
929 logicOp = createInfo.logicOp;
930 attachmentCount = static_cast<deUint32>(m_attachments.size());
931 pAttachments = &m_attachments[0];
932 deMemset(blendConstants, 0, sizeof(blendConstants));
933 }
934
ColorBlendState(const ColorBlendState & createInfo,std::vector<float> _blendConstants)935 PipelineCreateInfo::ColorBlendState::ColorBlendState (const ColorBlendState& createInfo, std::vector<float> _blendConstants)
936 : m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount)
937 {
938 sType = createInfo.sType;
939 pNext = createInfo.pNext;
940 flags = createInfo.flags;
941 logicOpEnable = createInfo.logicOpEnable;
942 logicOp = createInfo.logicOp;
943 attachmentCount = static_cast<deUint32>(m_attachments.size());
944 pAttachments = &m_attachments[0];
945 deMemcpy(blendConstants, &_blendConstants[0], 4 * sizeof(float));
946 }
947
Attachment(vk::VkBool32 _blendEnable,vk::VkBlendFactor _srcColorBlendFactor,vk::VkBlendFactor _dstColorBlendFactor,vk::VkBlendOp _colorBlendOp,vk::VkBlendFactor _srcAlphaBlendFactor,vk::VkBlendFactor _dstAlphaBlendFactor,vk::VkBlendOp _alphaBlendOp,vk::VkColorComponentFlags _colorWriteMask)948 PipelineCreateInfo::ColorBlendState::Attachment::Attachment (vk::VkBool32 _blendEnable,
949 vk::VkBlendFactor _srcColorBlendFactor,
950 vk::VkBlendFactor _dstColorBlendFactor,
951 vk::VkBlendOp _colorBlendOp,
952 vk::VkBlendFactor _srcAlphaBlendFactor,
953 vk::VkBlendFactor _dstAlphaBlendFactor,
954 vk::VkBlendOp _alphaBlendOp,
955 vk::VkColorComponentFlags _colorWriteMask)
956 {
957 blendEnable = _blendEnable;
958 srcColorBlendFactor = _srcColorBlendFactor;
959 dstColorBlendFactor = _dstColorBlendFactor;
960 colorBlendOp = _colorBlendOp;
961 srcAlphaBlendFactor = _srcAlphaBlendFactor;
962 dstAlphaBlendFactor = _dstAlphaBlendFactor;
963 alphaBlendOp = _alphaBlendOp;
964 colorWriteMask = _colorWriteMask;
965 }
966
StencilOpState(vk::VkStencilOp _failOp,vk::VkStencilOp _passOp,vk::VkStencilOp _depthFailOp,vk::VkCompareOp _compareOp,deUint32 _compareMask,deUint32 _writeMask,deUint32 _reference)967 PipelineCreateInfo::DepthStencilState::StencilOpState::StencilOpState (vk::VkStencilOp _failOp,
968 vk::VkStencilOp _passOp,
969 vk::VkStencilOp _depthFailOp,
970 vk::VkCompareOp _compareOp,
971 deUint32 _compareMask,
972 deUint32 _writeMask,
973 deUint32 _reference)
974 {
975 failOp = _failOp;
976 passOp = _passOp;
977 depthFailOp = _depthFailOp;
978 compareOp = _compareOp;
979
980 compareMask = _compareMask;
981 writeMask = _writeMask;
982 reference = _reference;
983 }
984
DepthStencilState(vk::VkBool32 _depthTestEnable,vk::VkBool32 _depthWriteEnable,vk::VkCompareOp _depthCompareOp,vk::VkBool32 _depthBoundsTestEnable,vk::VkBool32 _stencilTestEnable,StencilOpState _front,StencilOpState _back,float _minDepthBounds,float _maxDepthBounds)985 PipelineCreateInfo::DepthStencilState::DepthStencilState (vk::VkBool32 _depthTestEnable,
986 vk::VkBool32 _depthWriteEnable,
987 vk::VkCompareOp _depthCompareOp,
988 vk::VkBool32 _depthBoundsTestEnable,
989 vk::VkBool32 _stencilTestEnable,
990 StencilOpState _front,
991 StencilOpState _back,
992 float _minDepthBounds,
993 float _maxDepthBounds)
994 {
995 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
996 pNext = DE_NULL;
997 flags = 0u;
998 depthTestEnable = _depthTestEnable;
999 depthWriteEnable = _depthWriteEnable;
1000 depthCompareOp = _depthCompareOp;
1001 depthBoundsTestEnable = _depthBoundsTestEnable;
1002 stencilTestEnable = _stencilTestEnable;
1003 front = _front;
1004 back = _back;
1005
1006 minDepthBounds = _minDepthBounds;
1007 maxDepthBounds = _maxDepthBounds;
1008 }
1009
DynamicState(const std::vector<vk::VkDynamicState> & _dynamicStates)1010 PipelineCreateInfo::DynamicState::DynamicState (const std::vector<vk::VkDynamicState>& _dynamicStates)
1011 {
1012 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
1013 pNext = DE_NULL;
1014 flags = 0;
1015
1016 if (!_dynamicStates.size())
1017 {
1018 const vk::VkDynamicState dynamicState[] =
1019 {
1020 vk::VK_DYNAMIC_STATE_VIEWPORT,
1021 vk::VK_DYNAMIC_STATE_SCISSOR,
1022 vk::VK_DYNAMIC_STATE_LINE_WIDTH,
1023 vk::VK_DYNAMIC_STATE_DEPTH_BIAS,
1024 vk::VK_DYNAMIC_STATE_BLEND_CONSTANTS,
1025 vk::VK_DYNAMIC_STATE_DEPTH_BOUNDS,
1026 vk::VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
1027 vk::VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
1028 vk::VK_DYNAMIC_STATE_STENCIL_REFERENCE,
1029 };
1030
1031 for (size_t i = 0; i < DE_LENGTH_OF_ARRAY(dynamicState); ++i)
1032 {
1033 m_dynamicStates.push_back(dynamicState[i]);
1034 }
1035 }
1036 else
1037 m_dynamicStates = _dynamicStates;
1038
1039 dynamicStateCount = static_cast<deUint32>(m_dynamicStates.size());
1040 pDynamicStates = &m_dynamicStates[0];
1041 }
1042
DynamicState(const DynamicState & other)1043 PipelineCreateInfo::DynamicState::DynamicState (const DynamicState &other)
1044 {
1045 sType = other.sType;
1046 pNext = other.pNext;
1047
1048 flags = other.flags;
1049 dynamicStateCount = other.dynamicStateCount;
1050 m_dynamicStates = std::vector<vk::VkDynamicState>(other.pDynamicStates, other.pDynamicStates + dynamicStateCount);
1051 pDynamicStates = &m_dynamicStates[0];
1052 }
1053
operator =(const DynamicState & other)1054 PipelineCreateInfo::DynamicState& PipelineCreateInfo::DynamicState::operator= (const DynamicState& other)
1055 {
1056 sType = other.sType;
1057 pNext = other.pNext;
1058
1059 flags = other.flags;
1060 dynamicStateCount = other.dynamicStateCount;
1061 m_dynamicStates = std::vector<vk::VkDynamicState>(other.pDynamicStates, other.pDynamicStates + dynamicStateCount);
1062 pDynamicStates = &m_dynamicStates[0];
1063
1064 return *this;
1065 }
1066
PipelineCreateInfo(vk::VkPipelineLayout _layout,vk::VkRenderPass _renderPass,int _subpass,vk::VkPipelineCreateFlags _flags)1067 PipelineCreateInfo::PipelineCreateInfo (vk::VkPipelineLayout _layout,
1068 vk::VkRenderPass _renderPass,
1069 int _subpass,
1070 vk::VkPipelineCreateFlags _flags)
1071 {
1072 deMemset(static_cast<vk::VkGraphicsPipelineCreateInfo *>(this), 0,
1073 sizeof(vk::VkGraphicsPipelineCreateInfo));
1074
1075 sType = vk::VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
1076 pNext = DE_NULL;
1077 flags = _flags;
1078 renderPass = _renderPass;
1079 subpass = _subpass;
1080 layout = _layout;
1081 basePipelineHandle = DE_NULL;
1082 basePipelineIndex = 0;
1083 pDynamicState = DE_NULL;
1084 }
1085
addShader(const vk::VkPipelineShaderStageCreateInfo & shader)1086 PipelineCreateInfo& PipelineCreateInfo::addShader (const vk::VkPipelineShaderStageCreateInfo& shader)
1087 {
1088 m_shaders.push_back(shader);
1089
1090 stageCount = static_cast<deUint32>(m_shaders.size());
1091 pStages = &m_shaders[0];
1092
1093 return *this;
1094 }
1095
addState(const vk::VkPipelineVertexInputStateCreateInfo & state)1096 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineVertexInputStateCreateInfo& state)
1097 {
1098 m_vertexInputState = state;
1099 pVertexInputState = &m_vertexInputState;
1100
1101 return *this;
1102 }
1103
addState(const vk::VkPipelineInputAssemblyStateCreateInfo & state)1104 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineInputAssemblyStateCreateInfo& state)
1105 {
1106 m_inputAssemblyState = state;
1107 pInputAssemblyState = &m_inputAssemblyState;
1108
1109 return *this;
1110 }
1111
addState(const vk::VkPipelineColorBlendStateCreateInfo & state)1112 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineColorBlendStateCreateInfo& state)
1113 {
1114 m_colorBlendStateAttachments = std::vector<vk::VkPipelineColorBlendAttachmentState>(state.pAttachments, state.pAttachments + state.attachmentCount);
1115 m_colorBlendState = state;
1116 m_colorBlendState.pAttachments = &m_colorBlendStateAttachments[0];
1117 pColorBlendState = &m_colorBlendState;
1118
1119 return *this;
1120 }
1121
addState(const vk::VkPipelineViewportStateCreateInfo & state)1122 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineViewportStateCreateInfo& state)
1123 {
1124 m_viewports = std::vector<vk::VkViewport>(state.pViewports, state.pViewports + state.viewportCount);
1125 m_scissors = std::vector<vk::VkRect2D>(state.pScissors, state.pScissors + state.scissorCount);
1126 m_viewportState = state;
1127 m_viewportState.pViewports = &m_viewports[0];
1128 m_viewportState.pScissors = &m_scissors[0];
1129 pViewportState = &m_viewportState;
1130
1131 return *this;
1132 }
1133
addState(const vk::VkPipelineDepthStencilStateCreateInfo & state)1134 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineDepthStencilStateCreateInfo& state)
1135 {
1136 m_dynamicDepthStencilState = state;
1137 pDepthStencilState = &m_dynamicDepthStencilState;
1138 return *this;
1139 }
1140
addState(const vk::VkPipelineTessellationStateCreateInfo & state)1141 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineTessellationStateCreateInfo& state)
1142 {
1143 m_tessState = state;
1144 pTessellationState = &m_tessState;
1145
1146 return *this;
1147 }
1148
addState(const vk::VkPipelineRasterizationStateCreateInfo & state)1149 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineRasterizationStateCreateInfo& state)
1150 {
1151 m_rasterState = state;
1152 pRasterizationState = &m_rasterState;
1153
1154 return *this;
1155 }
1156
addState(const vk::VkPipelineMultisampleStateCreateInfo & state)1157 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineMultisampleStateCreateInfo& state)
1158 {
1159
1160 const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + state.rasterizationSamples) / ( sizeof(vk::VkSampleMask) * 8 );
1161 m_multisampleState = state;
1162 if (state.pSampleMask != DE_NULL)
1163 {
1164 m_multisampleStateSampleMask = std::vector<vk::VkSampleMask>(state.pSampleMask, state.pSampleMask + sampleMaskArrayLen);
1165 m_multisampleState.pSampleMask = &m_multisampleStateSampleMask[0];
1166 }
1167 pMultisampleState = &m_multisampleState;
1168
1169 return *this;
1170 }
addState(const vk::VkPipelineDynamicStateCreateInfo & state)1171 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineDynamicStateCreateInfo& state)
1172 {
1173 m_dynamicStates = std::vector<vk::VkDynamicState>(state.pDynamicStates, state.pDynamicStates + state.dynamicStateCount);
1174 m_dynamicState = state;
1175 m_dynamicState.pDynamicStates = &m_dynamicStates[0];
1176 pDynamicState = &m_dynamicState;
1177
1178 return *this;
1179 }
1180
SamplerCreateInfo(vk::VkFilter _magFilter,vk::VkFilter _minFilter,vk::VkSamplerMipmapMode _mipmapMode,vk::VkSamplerAddressMode _addressModeU,vk::VkSamplerAddressMode _addressModeV,vk::VkSamplerAddressMode _addressModeW,float _mipLodBias,vk::VkBool32 _anisotropyEnable,float _maxAnisotropy,vk::VkBool32 _compareEnable,vk::VkCompareOp _compareOp,float _minLod,float _maxLod,vk::VkBorderColor _borderColor,vk::VkBool32 _unnormalizedCoordinates)1181 SamplerCreateInfo::SamplerCreateInfo (vk::VkFilter _magFilter,
1182 vk::VkFilter _minFilter,
1183 vk::VkSamplerMipmapMode _mipmapMode,
1184 vk::VkSamplerAddressMode _addressModeU,
1185 vk::VkSamplerAddressMode _addressModeV,
1186 vk::VkSamplerAddressMode _addressModeW,
1187 float _mipLodBias,
1188 vk::VkBool32 _anisotropyEnable,
1189 float _maxAnisotropy,
1190 vk::VkBool32 _compareEnable,
1191 vk::VkCompareOp _compareOp,
1192 float _minLod,
1193 float _maxLod,
1194 vk::VkBorderColor _borderColor,
1195 vk::VkBool32 _unnormalizedCoordinates)
1196 {
1197 sType = vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
1198 pNext = DE_NULL;
1199 flags = 0u;
1200 magFilter = _magFilter;
1201 minFilter = _minFilter;
1202 mipmapMode = _mipmapMode;
1203 addressModeU = _addressModeU;
1204 addressModeV = _addressModeV;
1205 addressModeW = _addressModeW;
1206 mipLodBias = _mipLodBias;
1207 anisotropyEnable = _anisotropyEnable;
1208 maxAnisotropy = _maxAnisotropy;
1209 compareEnable = _compareEnable;
1210 compareOp = _compareOp;
1211 minLod = _minLod;
1212 maxLod = _maxLod;
1213 borderColor = _borderColor;
1214 unnormalizedCoordinates = _unnormalizedCoordinates;
1215 }
1216 } // Draw
1217 } // vkt
1218