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 }
904
ColorBlendState(deUint32 _attachmentCount,const vk::VkPipelineColorBlendAttachmentState * _attachments,vk::VkBool32 _logicOpEnable,vk::VkLogicOp _logicOp)905 PipelineCreateInfo::ColorBlendState::ColorBlendState (deUint32 _attachmentCount,
906 const vk::VkPipelineColorBlendAttachmentState* _attachments,
907 vk::VkBool32 _logicOpEnable,
908 vk::VkLogicOp _logicOp)
909 : m_attachments(_attachments, _attachments + _attachmentCount)
910 {
911 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
912 pNext = DE_NULL;
913 flags = 0;
914 logicOpEnable = _logicOpEnable;
915 logicOp = _logicOp;
916 attachmentCount = static_cast<deUint32>(m_attachments.size());
917 pAttachments = &m_attachments[0];
918 }
919
ColorBlendState(const vk::VkPipelineColorBlendStateCreateInfo & createInfo)920 PipelineCreateInfo::ColorBlendState::ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo& createInfo)
921 : m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount)
922 {
923 sType = createInfo.sType;
924 pNext = createInfo.pNext;
925 flags = createInfo.flags;
926 logicOpEnable = createInfo.logicOpEnable;
927 logicOp = createInfo.logicOp;
928 attachmentCount = static_cast<deUint32>(m_attachments.size());
929 pAttachments = &m_attachments[0];
930 }
931
ColorBlendState(const ColorBlendState & createInfo,std::vector<float> _blendConstants)932 PipelineCreateInfo::ColorBlendState::ColorBlendState (const ColorBlendState& createInfo, std::vector<float> _blendConstants)
933 : m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount)
934 {
935 sType = createInfo.sType;
936 pNext = createInfo.pNext;
937 flags = createInfo.flags;
938 logicOpEnable = createInfo.logicOpEnable;
939 logicOp = createInfo.logicOp;
940 attachmentCount = static_cast<deUint32>(m_attachments.size());
941 pAttachments = &m_attachments[0];
942 deMemcpy(blendConstants, &_blendConstants[0], 4 * sizeof(float));
943 }
944
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)945 PipelineCreateInfo::ColorBlendState::Attachment::Attachment (vk::VkBool32 _blendEnable,
946 vk::VkBlendFactor _srcColorBlendFactor,
947 vk::VkBlendFactor _dstColorBlendFactor,
948 vk::VkBlendOp _colorBlendOp,
949 vk::VkBlendFactor _srcAlphaBlendFactor,
950 vk::VkBlendFactor _dstAlphaBlendFactor,
951 vk::VkBlendOp _alphaBlendOp,
952 vk::VkColorComponentFlags _colorWriteMask)
953 {
954 blendEnable = _blendEnable;
955 srcColorBlendFactor = _srcColorBlendFactor;
956 dstColorBlendFactor = _dstColorBlendFactor;
957 colorBlendOp = _colorBlendOp;
958 srcAlphaBlendFactor = _srcAlphaBlendFactor;
959 dstAlphaBlendFactor = _dstAlphaBlendFactor;
960 alphaBlendOp = _alphaBlendOp;
961 colorWriteMask = _colorWriteMask;
962 }
963
StencilOpState(vk::VkStencilOp _failOp,vk::VkStencilOp _passOp,vk::VkStencilOp _depthFailOp,vk::VkCompareOp _compareOp,deUint32 _compareMask,deUint32 _writeMask,deUint32 _reference)964 PipelineCreateInfo::DepthStencilState::StencilOpState::StencilOpState (vk::VkStencilOp _failOp,
965 vk::VkStencilOp _passOp,
966 vk::VkStencilOp _depthFailOp,
967 vk::VkCompareOp _compareOp,
968 deUint32 _compareMask,
969 deUint32 _writeMask,
970 deUint32 _reference)
971 {
972 failOp = _failOp;
973 passOp = _passOp;
974 depthFailOp = _depthFailOp;
975 compareOp = _compareOp;
976
977 compareMask = _compareMask;
978 writeMask = _writeMask;
979 reference = _reference;
980 }
981
DepthStencilState(vk::VkBool32 _depthTestEnable,vk::VkBool32 _depthWriteEnable,vk::VkCompareOp _depthCompareOp,vk::VkBool32 _depthBoundsTestEnable,vk::VkBool32 _stencilTestEnable,StencilOpState _front,StencilOpState _back,float _minDepthBounds,float _maxDepthBounds)982 PipelineCreateInfo::DepthStencilState::DepthStencilState (vk::VkBool32 _depthTestEnable,
983 vk::VkBool32 _depthWriteEnable,
984 vk::VkCompareOp _depthCompareOp,
985 vk::VkBool32 _depthBoundsTestEnable,
986 vk::VkBool32 _stencilTestEnable,
987 StencilOpState _front,
988 StencilOpState _back,
989 float _minDepthBounds,
990 float _maxDepthBounds)
991 {
992 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
993 pNext = DE_NULL;
994 flags = 0u;
995 depthTestEnable = _depthTestEnable;
996 depthWriteEnable = _depthWriteEnable;
997 depthCompareOp = _depthCompareOp;
998 depthBoundsTestEnable = _depthBoundsTestEnable;
999 stencilTestEnable = _stencilTestEnable;
1000 front = _front;
1001 back = _back;
1002
1003 minDepthBounds = _minDepthBounds;
1004 maxDepthBounds = _maxDepthBounds;
1005 }
1006
DynamicState(const std::vector<vk::VkDynamicState> & _dynamicStates)1007 PipelineCreateInfo::DynamicState::DynamicState (const std::vector<vk::VkDynamicState>& _dynamicStates)
1008 {
1009 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
1010 pNext = DE_NULL;
1011 flags = 0;
1012
1013 if (!_dynamicStates.size())
1014 {
1015 const vk::VkDynamicState dynamicState[] =
1016 {
1017 vk::VK_DYNAMIC_STATE_VIEWPORT,
1018 vk::VK_DYNAMIC_STATE_SCISSOR,
1019 vk::VK_DYNAMIC_STATE_LINE_WIDTH,
1020 vk::VK_DYNAMIC_STATE_DEPTH_BIAS,
1021 vk::VK_DYNAMIC_STATE_BLEND_CONSTANTS,
1022 vk::VK_DYNAMIC_STATE_DEPTH_BOUNDS,
1023 vk::VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
1024 vk::VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
1025 vk::VK_DYNAMIC_STATE_STENCIL_REFERENCE,
1026 };
1027
1028 for (size_t i = 0; i < DE_LENGTH_OF_ARRAY(dynamicState); ++i)
1029 {
1030 m_dynamicStates.push_back(dynamicState[i]);
1031 }
1032 }
1033 else
1034 m_dynamicStates = _dynamicStates;
1035
1036 dynamicStateCount = static_cast<deUint32>(m_dynamicStates.size());
1037 pDynamicStates = &m_dynamicStates[0];
1038 }
1039
DynamicState(const DynamicState & other)1040 PipelineCreateInfo::DynamicState::DynamicState (const DynamicState &other)
1041 {
1042 sType = other.sType;
1043 pNext = other.pNext;
1044
1045 flags = other.flags;
1046 dynamicStateCount = other.dynamicStateCount;
1047 m_dynamicStates = std::vector<vk::VkDynamicState>(other.pDynamicStates, other.pDynamicStates + dynamicStateCount);
1048 pDynamicStates = &m_dynamicStates[0];
1049 }
1050
operator =(const DynamicState & other)1051 PipelineCreateInfo::DynamicState& PipelineCreateInfo::DynamicState::operator= (const DynamicState& other)
1052 {
1053 sType = other.sType;
1054 pNext = other.pNext;
1055
1056 flags = other.flags;
1057 dynamicStateCount = other.dynamicStateCount;
1058 m_dynamicStates = std::vector<vk::VkDynamicState>(other.pDynamicStates, other.pDynamicStates + dynamicStateCount);
1059 pDynamicStates = &m_dynamicStates[0];
1060
1061 return *this;
1062 }
1063
PipelineCreateInfo(vk::VkPipelineLayout _layout,vk::VkRenderPass _renderPass,int _subpass,vk::VkPipelineCreateFlags _flags)1064 PipelineCreateInfo::PipelineCreateInfo (vk::VkPipelineLayout _layout,
1065 vk::VkRenderPass _renderPass,
1066 int _subpass,
1067 vk::VkPipelineCreateFlags _flags)
1068 {
1069 deMemset(static_cast<vk::VkGraphicsPipelineCreateInfo *>(this), 0,
1070 sizeof(vk::VkGraphicsPipelineCreateInfo));
1071
1072 sType = vk::VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
1073 pNext = DE_NULL;
1074 flags = _flags;
1075 renderPass = _renderPass;
1076 subpass = _subpass;
1077 layout = _layout;
1078 basePipelineHandle = DE_NULL;
1079 basePipelineIndex = 0;
1080 pDynamicState = DE_NULL;
1081 }
1082
addShader(const vk::VkPipelineShaderStageCreateInfo & shader)1083 PipelineCreateInfo& PipelineCreateInfo::addShader (const vk::VkPipelineShaderStageCreateInfo& shader)
1084 {
1085 m_shaders.push_back(shader);
1086
1087 stageCount = static_cast<deUint32>(m_shaders.size());
1088 pStages = &m_shaders[0];
1089
1090 return *this;
1091 }
1092
addState(const vk::VkPipelineVertexInputStateCreateInfo & state)1093 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineVertexInputStateCreateInfo& state)
1094 {
1095 m_vertexInputState = state;
1096 pVertexInputState = &m_vertexInputState;
1097
1098 return *this;
1099 }
1100
addState(const vk::VkPipelineInputAssemblyStateCreateInfo & state)1101 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineInputAssemblyStateCreateInfo& state)
1102 {
1103 m_inputAssemblyState = state;
1104 pInputAssemblyState = &m_inputAssemblyState;
1105
1106 return *this;
1107 }
1108
addState(const vk::VkPipelineColorBlendStateCreateInfo & state)1109 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineColorBlendStateCreateInfo& state)
1110 {
1111 m_colorBlendStateAttachments = std::vector<vk::VkPipelineColorBlendAttachmentState>(state.pAttachments, state.pAttachments + state.attachmentCount);
1112 m_colorBlendState = state;
1113 m_colorBlendState.pAttachments = &m_colorBlendStateAttachments[0];
1114 pColorBlendState = &m_colorBlendState;
1115
1116 return *this;
1117 }
1118
addState(const vk::VkPipelineViewportStateCreateInfo & state)1119 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineViewportStateCreateInfo& state)
1120 {
1121 m_viewports = std::vector<vk::VkViewport>(state.pViewports, state.pViewports + state.viewportCount);
1122 m_scissors = std::vector<vk::VkRect2D>(state.pScissors, state.pScissors + state.scissorCount);
1123 m_viewportState = state;
1124 m_viewportState.pViewports = &m_viewports[0];
1125 m_viewportState.pScissors = &m_scissors[0];
1126 pViewportState = &m_viewportState;
1127
1128 return *this;
1129 }
1130
addState(const vk::VkPipelineDepthStencilStateCreateInfo & state)1131 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineDepthStencilStateCreateInfo& state)
1132 {
1133 m_dynamicDepthStencilState = state;
1134 pDepthStencilState = &m_dynamicDepthStencilState;
1135 return *this;
1136 }
1137
addState(const vk::VkPipelineTessellationStateCreateInfo & state)1138 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineTessellationStateCreateInfo& state)
1139 {
1140 m_tessState = state;
1141 pTessellationState = &m_tessState;
1142
1143 return *this;
1144 }
1145
addState(const vk::VkPipelineRasterizationStateCreateInfo & state)1146 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineRasterizationStateCreateInfo& state)
1147 {
1148 m_rasterState = state;
1149 pRasterizationState = &m_rasterState;
1150
1151 return *this;
1152 }
1153
addState(const vk::VkPipelineMultisampleStateCreateInfo & state)1154 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineMultisampleStateCreateInfo& state)
1155 {
1156
1157 const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + state.rasterizationSamples) / ( sizeof(vk::VkSampleMask) * 8 );
1158 m_multisampleStateSampleMask = std::vector<vk::VkSampleMask>(state.pSampleMask, state.pSampleMask + sampleMaskArrayLen);
1159 m_multisampleState = state;
1160 m_multisampleState.pSampleMask = &m_multisampleStateSampleMask[0];
1161 pMultisampleState = &m_multisampleState;
1162
1163 return *this;
1164 }
addState(const vk::VkPipelineDynamicStateCreateInfo & state)1165 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineDynamicStateCreateInfo& state)
1166 {
1167 m_dynamicStates = std::vector<vk::VkDynamicState>(state.pDynamicStates, state.pDynamicStates + state.dynamicStateCount);
1168 m_dynamicState = state;
1169 m_dynamicState.pDynamicStates = &m_dynamicStates[0];
1170 pDynamicState = &m_dynamicState;
1171
1172 return *this;
1173 }
1174
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)1175 SamplerCreateInfo::SamplerCreateInfo (vk::VkFilter _magFilter,
1176 vk::VkFilter _minFilter,
1177 vk::VkSamplerMipmapMode _mipmapMode,
1178 vk::VkSamplerAddressMode _addressModeU,
1179 vk::VkSamplerAddressMode _addressModeV,
1180 vk::VkSamplerAddressMode _addressModeW,
1181 float _mipLodBias,
1182 vk::VkBool32 _anisotropyEnable,
1183 float _maxAnisotropy,
1184 vk::VkBool32 _compareEnable,
1185 vk::VkCompareOp _compareOp,
1186 float _minLod,
1187 float _maxLod,
1188 vk::VkBorderColor _borderColor,
1189 vk::VkBool32 _unnormalizedCoordinates)
1190 {
1191 sType = vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
1192 pNext = DE_NULL;
1193 flags = 0u;
1194 magFilter = _magFilter;
1195 minFilter = _minFilter;
1196 mipmapMode = _mipmapMode;
1197 addressModeU = _addressModeU;
1198 addressModeV = _addressModeV;
1199 addressModeW = _addressModeW;
1200 mipLodBias = _mipLodBias;
1201 anisotropyEnable = _anisotropyEnable;
1202 maxAnisotropy = _maxAnisotropy;
1203 compareEnable = _compareEnable;
1204 compareOp = _compareOp;
1205 minLod = _minLod;
1206 maxLod = _maxLod;
1207 borderColor = _borderColor;
1208 unnormalizedCoordinates = _unnormalizedCoordinates;
1209 }
1210 } // Draw
1211 } // vkt
1212