src/WSI/VkSwapchainKHR.cpp

// Copyright 2019 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "VkSwapchainKHR.hpp"

#include "Vulkan/VkImage.hpp"
#include "Vulkan/VkDeviceMemory.hpp"
#include "Vulkan/VkDestroy.h"

namespace vk
{

SwapchainKHR::SwapchainKHR(const VkSwapchainCreateInfoKHR *pCreateInfo, void *mem) :
	createInfo(*pCreateInfo),
	imageCount(0)
{
	images.resize(pCreateInfo->minImageCount);
	resetImages();
}

void SwapchainKHR::destroy(const VkAllocationCallbacks *pAllocator)
{
	for(auto& currentImage : images)
	{
		if (currentImage.imageStatus != NONEXISTENT)
		{
			vk::destroy(currentImage.imageMemory, pAllocator);
			vk::destroy(currentImage.image, pAllocator);

			currentImage.imageStatus = NONEXISTENT;
		}
	}
}

size_t SwapchainKHR::ComputeRequiredAllocationSize(const VkSwapchainCreateInfoKHR *pCreateInfo)
{
	return 0;
}

void SwapchainKHR::resetImages()
{
	for(auto& currentImage : images)
	{
		currentImage.image = VK_NULL_HANDLE;
		currentImage.imageMemory = VK_NULL_HANDLE;
		currentImage.imageStatus = NONEXISTENT;
	}
}

VkResult SwapchainKHR::createImages(VkDevice device)
{
	resetImages();

	VkImageCreateInfo imageInfo = {};
	imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;

	if(createInfo.flags & VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR)
	{
		imageInfo.flags |= VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT;
	}

	if(createInfo.flags & VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR)
	{
		imageInfo.flags |= VK_IMAGE_CREATE_PROTECTED_BIT;
	}

	imageInfo.imageType = VK_IMAGE_TYPE_2D;
	imageInfo.format = createInfo.imageFormat;
	imageInfo.extent.height = createInfo.imageExtent.height;
	imageInfo.extent.width = createInfo.imageExtent.width;
	imageInfo.extent.depth = 1;
	imageInfo.mipLevels = 1;
	imageInfo.arrayLayers = createInfo.imageArrayLayers;
	imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
	imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
	imageInfo.usage = createInfo.imageUsage;
	imageInfo.sharingMode = createInfo.imageSharingMode;
	imageInfo.pQueueFamilyIndices = createInfo.pQueueFamilyIndices;
	imageInfo.queueFamilyIndexCount = createInfo.queueFamilyIndexCount;
	imageInfo.initialLayout = VK_IMAGE_LAYOUT_GENERAL;

	VkResult status;
	for(auto& currentImage : images)
	{
		status = vkCreateImage(device, &imageInfo, nullptr, &currentImage.image);
		if(status != VK_SUCCESS)
		{
			return status;
		}

		VkMemoryRequirements memRequirements = vk::Cast(currentImage.image)->getMemoryRequirements();

		VkMemoryAllocateInfo allocInfo = {};
		allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
		allocInfo.allocationSize = memRequirements.size;
		allocInfo.memoryTypeIndex = 0;

		status = vkAllocateMemory(device, &allocInfo, nullptr, &currentImage.imageMemory);
		if(status != VK_SUCCESS)
		{
			return status;
		}

		vkBindImageMemory(device, currentImage.image, currentImage.imageMemory, 0);

		currentImage.imageStatus = AVAILABLE;
	}

	return VK_SUCCESS;
}

}