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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 441 AttachmentReference::AttachmentReference (deUint32 _attachment, vk::VkImageLayout _layout) 442 { 443 attachment = _attachment; 444 layout = _layout; 445 } 446 447 AttachmentReference::AttachmentReference (void) 448 { 449 attachment = VK_ATTACHMENT_UNUSED; 450 layout = vk::VK_IMAGE_LAYOUT_UNDEFINED; 451 } 452 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 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 533 SubpassDescription::SubpassDescription (const SubpassDescription& rhs) { 534 *this = rhs; 535 } 536 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 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 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 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 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 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 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 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 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 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 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 716 PipelineCreateInfo::InputAssemblerState::InputAssemblerState (vk::VkPrimitiveTopology _topology, 717 vk::VkBool32 _primitiveRestartEnable) 718 { 719 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; 720 pNext = DE_NULL; 721 flags = 0u; 722 topology = _topology; 723 primitiveRestartEnable = _primitiveRestartEnable; 724 } 725 726 PipelineCreateInfo::TessellationState::TessellationState (deUint32 _patchControlPoints) 727 { 728 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO; 729 pNext = DE_NULL; 730 flags = 0; 731 patchControlPoints = _patchControlPoints; 732 } 733 734 PipelineCreateInfo::ViewportState::ViewportState (deUint32 _viewportCount, 735 std::vector<vk::VkViewport> _viewports, 736 std::vector<vk::VkRect2D> _scissors) 737 { 738 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; 739 pNext = DE_NULL; 740 flags = 0u; 741 viewportCount = _viewportCount; 742 scissorCount = _viewportCount; 743 744 if (!_viewports.size()) 745 { 746 m_viewports.resize(viewportCount); 747 deMemset(&m_viewports[0], 0, sizeof(m_viewports[0]) * m_viewports.size()); 748 } 749 else 750 { 751 m_viewports = _viewports; 752 } 753 754 if (!_scissors.size()) 755 { 756 m_scissors.resize(scissorCount); 757 deMemset(&m_scissors[0], 0, sizeof(m_scissors[0]) * m_scissors.size()); 758 } 759 else 760 { 761 m_scissors = _scissors; 762 } 763 764 pViewports = &m_viewports[0]; 765 pScissors = &m_scissors[0]; 766 } 767 768 PipelineCreateInfo::ViewportState::ViewportState (const ViewportState& other) 769 { 770 sType = other.sType; 771 pNext = other.pNext; 772 flags = other.flags; 773 viewportCount = other.viewportCount; 774 scissorCount = other.scissorCount; 775 776 m_viewports = std::vector<vk::VkViewport>(other.pViewports, other.pViewports + viewportCount); 777 m_scissors = std::vector<vk::VkRect2D>(other.pScissors, other.pScissors + scissorCount); 778 779 pViewports = &m_viewports[0]; 780 pScissors = &m_scissors[0]; 781 } 782 783 PipelineCreateInfo::ViewportState& PipelineCreateInfo::ViewportState::operator= (const ViewportState& other) 784 { 785 sType = other.sType; 786 pNext = other.pNext; 787 flags = other.flags; 788 viewportCount = other.viewportCount; 789 scissorCount = other.scissorCount; 790 791 m_viewports = std::vector<vk::VkViewport>(other.pViewports, other.pViewports + scissorCount); 792 m_scissors = std::vector<vk::VkRect2D>(other.pScissors, other.pScissors + scissorCount); 793 794 pViewports = &m_viewports[0]; 795 pScissors = &m_scissors[0]; 796 return *this; 797 } 798 799 PipelineCreateInfo::RasterizerState::RasterizerState (vk::VkBool32 _depthClampEnable, 800 vk::VkBool32 _rasterizerDiscardEnable, 801 vk::VkPolygonMode _polygonMode, 802 vk::VkCullModeFlags _cullMode, 803 vk::VkFrontFace _frontFace, 804 vk::VkBool32 _depthBiasEnable, 805 float _depthBiasConstantFactor, 806 float _depthBiasClamp, 807 float _depthBiasSlopeFactor, 808 float _lineWidth) 809 { 810 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; 811 pNext = DE_NULL; 812 flags = 0u; 813 depthClampEnable = _depthClampEnable; 814 rasterizerDiscardEnable = _rasterizerDiscardEnable; 815 polygonMode = _polygonMode; 816 cullMode = _cullMode; 817 frontFace = _frontFace; 818 819 depthBiasEnable = _depthBiasEnable; 820 depthBiasConstantFactor = _depthBiasConstantFactor; 821 depthBiasClamp = _depthBiasClamp; 822 depthBiasSlopeFactor = _depthBiasSlopeFactor; 823 lineWidth = _lineWidth; 824 } 825 826 PipelineCreateInfo::MultiSampleState::MultiSampleState (vk::VkSampleCountFlagBits _rasterizationSamples, 827 vk::VkBool32 _sampleShadingEnable, 828 float _minSampleShading, 829 const std::vector<vk::VkSampleMask>& _sampleMask, 830 bool _alphaToCoverageEnable, 831 bool _alphaToOneEnable) 832 : m_sampleMask(_sampleMask) 833 { 834 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; 835 pNext = DE_NULL; 836 flags = 0u; 837 rasterizationSamples = _rasterizationSamples; 838 sampleShadingEnable = _sampleShadingEnable; 839 minSampleShading = _minSampleShading; 840 pSampleMask = &m_sampleMask[0]; 841 alphaToCoverageEnable = _alphaToCoverageEnable; 842 alphaToOneEnable = _alphaToOneEnable; 843 } 844 845 PipelineCreateInfo::MultiSampleState::MultiSampleState (const MultiSampleState& other) 846 { 847 sType = other.sType; 848 pNext = other.pNext; 849 flags = other.flags; 850 rasterizationSamples = other.rasterizationSamples; 851 sampleShadingEnable = other.sampleShadingEnable; 852 minSampleShading = other.minSampleShading; 853 854 const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + other.rasterizationSamples) / (sizeof(vk::VkSampleMask) * 8); 855 856 m_sampleMask = std::vector<vk::VkSampleMask>(other.pSampleMask, other.pSampleMask + sampleMaskArrayLen); 857 pSampleMask = &m_sampleMask[0]; 858 } 859 860 PipelineCreateInfo::MultiSampleState& PipelineCreateInfo::MultiSampleState::operator= (const MultiSampleState& other) 861 { 862 sType = other.sType; 863 pNext = other.pNext; 864 flags = other.flags; 865 rasterizationSamples = other.rasterizationSamples; 866 sampleShadingEnable = other.sampleShadingEnable; 867 minSampleShading = other.minSampleShading; 868 869 const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + other.rasterizationSamples) / (sizeof(vk::VkSampleMask) * 8); 870 871 m_sampleMask = std::vector<vk::VkSampleMask>(other.pSampleMask, other.pSampleMask + sampleMaskArrayLen); 872 pSampleMask = &m_sampleMask[0]; 873 874 return *this; 875 } 876 877 PipelineCreateInfo::ColorBlendState::ColorBlendState (const std::vector<vk::VkPipelineColorBlendAttachmentState>& _attachments, 878 vk::VkBool32 _logicOpEnable, 879 vk::VkLogicOp _logicOp) 880 : m_attachments(_attachments) 881 { 882 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; 883 pNext = DE_NULL; 884 flags = 0u; 885 logicOpEnable = _logicOpEnable; 886 logicOp = _logicOp; 887 attachmentCount = static_cast<deUint32>(m_attachments.size()); 888 pAttachments = &m_attachments[0]; 889 } 890 891 PipelineCreateInfo::ColorBlendState::ColorBlendState (deUint32 _attachmentCount, 892 const vk::VkPipelineColorBlendAttachmentState* _attachments, 893 vk::VkBool32 _logicOpEnable, 894 vk::VkLogicOp _logicOp) 895 : m_attachments(_attachments, _attachments + _attachmentCount) 896 { 897 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; 898 pNext = DE_NULL; 899 flags = 0; 900 logicOpEnable = _logicOpEnable; 901 logicOp = _logicOp; 902 attachmentCount = static_cast<deUint32>(m_attachments.size()); 903 pAttachments = &m_attachments[0]; 904 } 905 906 PipelineCreateInfo::ColorBlendState::ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo& createInfo) 907 : m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount) 908 { 909 sType = createInfo.sType; 910 pNext = createInfo.pNext; 911 flags = createInfo.flags; 912 logicOpEnable = createInfo.logicOpEnable; 913 logicOp = createInfo.logicOp; 914 attachmentCount = static_cast<deUint32>(m_attachments.size()); 915 pAttachments = &m_attachments[0]; 916 } 917 918 PipelineCreateInfo::ColorBlendState::ColorBlendState (const ColorBlendState& createInfo, std::vector<float> _blendConstants) 919 : m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount) 920 { 921 sType = createInfo.sType; 922 pNext = createInfo.pNext; 923 flags = createInfo.flags; 924 logicOpEnable = createInfo.logicOpEnable; 925 logicOp = createInfo.logicOp; 926 attachmentCount = static_cast<deUint32>(m_attachments.size()); 927 pAttachments = &m_attachments[0]; 928 deMemcpy(blendConstants, &_blendConstants[0], 4 * sizeof(float)); 929 } 930 931 PipelineCreateInfo::ColorBlendState::Attachment::Attachment (vk::VkBool32 _blendEnable, 932 vk::VkBlendFactor _srcColorBlendFactor, 933 vk::VkBlendFactor _dstColorBlendFactor, 934 vk::VkBlendOp _colorBlendOp, 935 vk::VkBlendFactor _srcAlphaBlendFactor, 936 vk::VkBlendFactor _dstAlphaBlendFactor, 937 vk::VkBlendOp _alphaBlendOp, 938 vk::VkColorComponentFlags _colorWriteMask) 939 { 940 blendEnable = _blendEnable; 941 srcColorBlendFactor = _srcColorBlendFactor; 942 dstColorBlendFactor = _dstColorBlendFactor; 943 colorBlendOp = _colorBlendOp; 944 srcAlphaBlendFactor = _srcAlphaBlendFactor; 945 dstAlphaBlendFactor = _dstAlphaBlendFactor; 946 alphaBlendOp = _alphaBlendOp; 947 colorWriteMask = _colorWriteMask; 948 } 949 950 PipelineCreateInfo::DepthStencilState::StencilOpState::StencilOpState (vk::VkStencilOp _failOp, 951 vk::VkStencilOp _passOp, 952 vk::VkStencilOp _depthFailOp, 953 vk::VkCompareOp _compareOp, 954 deUint32 _compareMask, 955 deUint32 _writeMask, 956 deUint32 _reference) 957 { 958 failOp = _failOp; 959 passOp = _passOp; 960 depthFailOp = _depthFailOp; 961 compareOp = _compareOp; 962 963 compareMask = _compareMask; 964 writeMask = _writeMask; 965 reference = _reference; 966 } 967 968 PipelineCreateInfo::DepthStencilState::DepthStencilState (vk::VkBool32 _depthTestEnable, 969 vk::VkBool32 _depthWriteEnable, 970 vk::VkCompareOp _depthCompareOp, 971 vk::VkBool32 _depthBoundsTestEnable, 972 vk::VkBool32 _stencilTestEnable, 973 StencilOpState _front, 974 StencilOpState _back, 975 float _minDepthBounds, 976 float _maxDepthBounds) 977 { 978 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; 979 pNext = DE_NULL; 980 flags = 0u; 981 depthTestEnable = _depthTestEnable; 982 depthWriteEnable = _depthWriteEnable; 983 depthCompareOp = _depthCompareOp; 984 depthBoundsTestEnable = _depthBoundsTestEnable; 985 stencilTestEnable = _stencilTestEnable; 986 front = _front; 987 back = _back; 988 989 minDepthBounds = _minDepthBounds; 990 maxDepthBounds = _maxDepthBounds; 991 } 992 993 PipelineCreateInfo::DynamicState::DynamicState (const std::vector<vk::VkDynamicState>& _dynamicStates) 994 { 995 sType = vk::VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; 996 pNext = DE_NULL; 997 flags = 0; 998 999 if (!_dynamicStates.size()) 1000 { 1001 for (size_t i = 0; i < vk::VK_DYNAMIC_STATE_LAST; ++i) 1002 { 1003 m_dynamicStates.push_back(static_cast<vk::VkDynamicState>(i)); 1004 } 1005 } 1006 else 1007 m_dynamicStates = _dynamicStates; 1008 1009 dynamicStateCount = static_cast<deUint32>(m_dynamicStates.size()); 1010 pDynamicStates = &m_dynamicStates[0]; 1011 } 1012 1013 PipelineCreateInfo::DynamicState::DynamicState (const DynamicState &other) 1014 { 1015 sType = other.sType; 1016 pNext = other.pNext; 1017 1018 flags = other.flags; 1019 dynamicStateCount = other.dynamicStateCount; 1020 m_dynamicStates = std::vector<vk::VkDynamicState>(other.pDynamicStates, other.pDynamicStates + dynamicStateCount); 1021 pDynamicStates = &m_dynamicStates[0]; 1022 } 1023 1024 PipelineCreateInfo::DynamicState& PipelineCreateInfo::DynamicState::operator= (const DynamicState& other) 1025 { 1026 sType = other.sType; 1027 pNext = other.pNext; 1028 1029 flags = other.flags; 1030 dynamicStateCount = other.dynamicStateCount; 1031 m_dynamicStates = std::vector<vk::VkDynamicState>(other.pDynamicStates, other.pDynamicStates + dynamicStateCount); 1032 pDynamicStates = &m_dynamicStates[0]; 1033 1034 return *this; 1035 } 1036 1037 PipelineCreateInfo::PipelineCreateInfo (vk::VkPipelineLayout _layout, 1038 vk::VkRenderPass _renderPass, 1039 int _subpass, 1040 vk::VkPipelineCreateFlags _flags) 1041 { 1042 deMemset(static_cast<vk::VkGraphicsPipelineCreateInfo *>(this), 0, 1043 sizeof(vk::VkGraphicsPipelineCreateInfo)); 1044 1045 sType = vk::VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; 1046 pNext = DE_NULL; 1047 flags = _flags; 1048 renderPass = _renderPass; 1049 subpass = _subpass; 1050 layout = _layout; 1051 basePipelineHandle = DE_NULL; 1052 basePipelineIndex = 0; 1053 pDynamicState = DE_NULL; 1054 } 1055 1056 PipelineCreateInfo& PipelineCreateInfo::addShader (const vk::VkPipelineShaderStageCreateInfo& shader) 1057 { 1058 m_shaders.push_back(shader); 1059 1060 stageCount = static_cast<deUint32>(m_shaders.size()); 1061 pStages = &m_shaders[0]; 1062 1063 return *this; 1064 } 1065 1066 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineVertexInputStateCreateInfo& state) 1067 { 1068 m_vertexInputState = state; 1069 pVertexInputState = &m_vertexInputState; 1070 1071 return *this; 1072 } 1073 1074 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineInputAssemblyStateCreateInfo& state) 1075 { 1076 m_inputAssemblyState = state; 1077 pInputAssemblyState = &m_inputAssemblyState; 1078 1079 return *this; 1080 } 1081 1082 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineColorBlendStateCreateInfo& state) 1083 { 1084 m_colorBlendStateAttachments = std::vector<vk::VkPipelineColorBlendAttachmentState>(state.pAttachments, state.pAttachments + state.attachmentCount); 1085 m_colorBlendState = state; 1086 m_colorBlendState.pAttachments = &m_colorBlendStateAttachments[0]; 1087 pColorBlendState = &m_colorBlendState; 1088 1089 return *this; 1090 } 1091 1092 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineViewportStateCreateInfo& state) 1093 { 1094 m_viewports = std::vector<vk::VkViewport>(state.pViewports, state.pViewports + state.viewportCount); 1095 m_scissors = std::vector<vk::VkRect2D>(state.pScissors, state.pScissors + state.scissorCount); 1096 m_viewportState = state; 1097 m_viewportState.pViewports = &m_viewports[0]; 1098 m_viewportState.pScissors = &m_scissors[0]; 1099 pViewportState = &m_viewportState; 1100 1101 return *this; 1102 } 1103 1104 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineDepthStencilStateCreateInfo& state) 1105 { 1106 m_dynamicDepthStencilState = state; 1107 pDepthStencilState = &m_dynamicDepthStencilState; 1108 return *this; 1109 } 1110 1111 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineTessellationStateCreateInfo& state) 1112 { 1113 m_tessState = state; 1114 pTessellationState = &m_tessState; 1115 1116 return *this; 1117 } 1118 1119 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineRasterizationStateCreateInfo& state) 1120 { 1121 m_rasterState = state; 1122 pRasterizationState = &m_rasterState; 1123 1124 return *this; 1125 } 1126 1127 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineMultisampleStateCreateInfo& state) 1128 { 1129 1130 const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + state.rasterizationSamples) / ( sizeof(vk::VkSampleMask) * 8 ); 1131 m_multisampleStateSampleMask = std::vector<vk::VkSampleMask>(state.pSampleMask, state.pSampleMask + sampleMaskArrayLen); 1132 m_multisampleState = state; 1133 m_multisampleState.pSampleMask = &m_multisampleStateSampleMask[0]; 1134 pMultisampleState = &m_multisampleState; 1135 1136 return *this; 1137 } 1138 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineDynamicStateCreateInfo& state) 1139 { 1140 m_dynamicStates = std::vector<vk::VkDynamicState>(state.pDynamicStates, state.pDynamicStates + state.dynamicStateCount); 1141 m_dynamicState = state; 1142 m_dynamicState.pDynamicStates = &m_dynamicStates[0]; 1143 pDynamicState = &m_dynamicState; 1144 1145 return *this; 1146 } 1147 1148 SamplerCreateInfo::SamplerCreateInfo (vk::VkFilter _magFilter, 1149 vk::VkFilter _minFilter, 1150 vk::VkSamplerMipmapMode _mipmapMode, 1151 vk::VkSamplerAddressMode _addressModeU, 1152 vk::VkSamplerAddressMode _addressModeV, 1153 vk::VkSamplerAddressMode _addressModeW, 1154 float _mipLodBias, 1155 vk::VkBool32 _anisotropyEnable, 1156 float _maxAnisotropy, 1157 vk::VkBool32 _compareEnable, 1158 vk::VkCompareOp _compareOp, 1159 float _minLod, 1160 float _maxLod, 1161 vk::VkBorderColor _borderColor, 1162 vk::VkBool32 _unnormalizedCoordinates) 1163 { 1164 sType = vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; 1165 pNext = DE_NULL; 1166 flags = 0u; 1167 magFilter = _magFilter; 1168 minFilter = _minFilter; 1169 mipmapMode = _mipmapMode; 1170 addressModeU = _addressModeU; 1171 addressModeV = _addressModeV; 1172 addressModeW = _addressModeW; 1173 mipLodBias = _mipLodBias; 1174 anisotropyEnable = _anisotropyEnable; 1175 maxAnisotropy = _maxAnisotropy; 1176 compareEnable = _compareEnable; 1177 compareOp = _compareOp; 1178 minLod = _minLod; 1179 maxLod = _maxLod; 1180 borderColor = _borderColor; 1181 unnormalizedCoordinates = _unnormalizedCoordinates; 1182 } 1183 } // Draw 1184 } // vkt 1185
