src/Vulkan/VkDescriptorSetLayout.cpp - SwiftShader - Git at Google

 // Copyright 2018 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 "VkDescriptorSetLayout.hpp"

 #include "VkDescriptorSet.hpp"
 #include "VkSampler.hpp"
 #include "VkImageView.hpp"
 #include "System/Types.hpp"

 #include <algorithm>
 #include <cstring>

 namespace
 {

 static bool UsesImmutableSamplers(const VkDescriptorSetLayoutBinding& binding)
 {
 	return (((binding.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) ||
 	        (binding.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)) &&
 	        (binding.pImmutableSamplers != nullptr));
 }

 }

 namespace vk
 {

 DescriptorSetLayout::DescriptorSetLayout(const VkDescriptorSetLayoutCreateInfo* pCreateInfo, void* mem) :
 	flags(pCreateInfo->flags), bindingCount(pCreateInfo->bindingCount), bindings(reinterpret_cast<VkDescriptorSetLayoutBinding*>(mem))
 {
 	uint8_t* hostMemory = static_cast<uint8_t*>(mem) + bindingCount * sizeof(VkDescriptorSetLayoutBinding);
 	bindingOffsets = reinterpret_cast<size_t*>(hostMemory);
 	hostMemory += bindingCount * sizeof(size_t);

 	size_t offset = 0;
 	for(uint32_t i = 0; i < bindingCount; i++)
 	{
 		bindings[i] = pCreateInfo->pBindings[i];
 		if(UsesImmutableSamplers(bindings[i]))
 		{
 			size_t immutableSamplersSize = bindings[i].descriptorCount * sizeof(VkSampler);
 			bindings[i].pImmutableSamplers = reinterpret_cast<const VkSampler*>(hostMemory);
 			hostMemory += immutableSamplersSize;
 			memcpy(const_cast<VkSampler*>(bindings[i].pImmutableSamplers),
 			       pCreateInfo->pBindings[i].pImmutableSamplers,
 			       immutableSamplersSize);
 		}
 		else
 		{
 			bindings[i].pImmutableSamplers = nullptr;
 		}
 		bindingOffsets[i] = offset;
 		offset += bindings[i].descriptorCount * GetDescriptorSize(bindings[i].descriptorType);
 	}
 }

 void DescriptorSetLayout::destroy(const VkAllocationCallbacks* pAllocator)
 {
 	vk::deallocate(bindings, pAllocator); // This allocation also contains pImmutableSamplers
 }

 size_t DescriptorSetLayout::ComputeRequiredAllocationSize(const VkDescriptorSetLayoutCreateInfo* pCreateInfo)
 {
 	size_t allocationSize = pCreateInfo->bindingCount * (sizeof(VkDescriptorSetLayoutBinding) + sizeof(size_t));

 	for(uint32_t i = 0; i < pCreateInfo->bindingCount; i++)
 	{
 		if(UsesImmutableSamplers(pCreateInfo->pBindings[i]))
 		{
 			allocationSize += pCreateInfo->pBindings[i].descriptorCount * sizeof(VkSampler);
 		}
 	}

 	return allocationSize;
 }

 size_t DescriptorSetLayout::GetDescriptorSize(VkDescriptorType type)
 {
 	switch(type)
 	{
 	case VK_DESCRIPTOR_TYPE_SAMPLER:
 	case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
 	case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
 		return sizeof(SampledImageDescriptor);
 	case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
 	case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
 		return sizeof(VkDescriptorImageInfo);
 	case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
 	case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
 		return sizeof(VkBufferView);
 	case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
 	case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
 	case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
 	case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
 		return sizeof(VkDescriptorBufferInfo);
 	default:
 		UNIMPLEMENTED("Unsupported Descriptor Type");
 	}

 	return 0;
 }

 size_t DescriptorSetLayout::getDescriptorSetAllocationSize() const
 {
 	// vk::DescriptorSet has a layout member field.
 	return sizeof(vk::DescriptorSetLayout*) + getDescriptorSetDataSize();
 }

 size_t DescriptorSetLayout::getDescriptorSetDataSize() const
 {
 	size_t size = 0;
 	for(uint32_t i = 0; i < bindingCount; i++)
 	{
 		size += bindings[i].descriptorCount * GetDescriptorSize(bindings[i].descriptorType);
 	}

 	return size;
 }

 uint32_t DescriptorSetLayout::getBindingIndex(uint32_t binding) const
 {
 	for(uint32_t i = 0; i < bindingCount; i++)
 	{
 		if(binding == bindings[i].binding)
 		{
 			return i;
 		}
 	}

 	DABORT("Invalid DescriptorSetLayout binding: %d", int(binding));
 	return 0;
 }

 void DescriptorSetLayout::initialize(VkDescriptorSet vkDescriptorSet)
 {
 	// Use a pointer to this descriptor set layout as the descriptor set's header
 	DescriptorSet* descriptorSet = vk::Cast(vkDescriptorSet);
 	descriptorSet->layout = this;
 	uint8_t* mem = descriptorSet->data;

 	for(uint32_t i = 0; i < bindingCount; i++)
 	{
 		size_t typeSize = GetDescriptorSize(bindings[i].descriptorType);
 		if(UsesImmutableSamplers(bindings[i]))
 		{
 			for(uint32_t j = 0; j < bindings[i].descriptorCount; j++)
 			{
 				SampledImageDescriptor* imageSamplerDescriptor = reinterpret_cast<SampledImageDescriptor*>(mem);
 				imageSamplerDescriptor->sampler = vk::Cast(bindings[i].pImmutableSamplers[j]);
 				mem += typeSize;
 			}
 		}
 		else
 		{
 			mem += bindings[i].descriptorCount * typeSize;
 		}
 	}
 }

 size_t DescriptorSetLayout::getBindingCount() const
 {
 	return bindingCount;
 }

 size_t DescriptorSetLayout::getBindingOffset(uint32_t binding, size_t arrayElement) const
 {
 	uint32_t index = getBindingIndex(binding);
 	auto typeSize = GetDescriptorSize(bindings[index].descriptorType);
 	return bindingOffsets[index] + OFFSET(DescriptorSet, data[0]) + (typeSize * arrayElement);
 }

 bool DescriptorSetLayout::isDynamic(VkDescriptorType type)
 {
 	return type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC ||
 		   type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
 }

 bool DescriptorSetLayout::isBindingDynamic(uint32_t binding) const
 {
 	uint32_t index = getBindingIndex(binding);
 	return isDynamic(bindings[index].descriptorType);
 }

 uint32_t DescriptorSetLayout::getDynamicDescriptorCount() const
 {
 	uint32_t count = 0;
 	for (size_t i = 0; i < bindingCount; i++)
 	{
 		if (isDynamic(bindings[i].descriptorType))
 		{
 			count += bindings[i].descriptorCount;
 		}
 	}
 	return count;
 }

 uint32_t DescriptorSetLayout::getDynamicDescriptorOffset(uint32_t binding) const
 {
 	uint32_t n = getBindingIndex(binding);
 	ASSERT(isDynamic(bindings[n].descriptorType));

 	uint32_t index = 0;
 	for (uint32_t i = 0; i < n; i++)
 	{
 		if (isDynamic(bindings[i].descriptorType))
 		{
 			index += bindings[i].descriptorCount;
 		}
 	}
 	return index;
 }

 VkDescriptorSetLayoutBinding const & DescriptorSetLayout::getBindingLayout(uint32_t binding) const
 {
 	uint32_t index = getBindingIndex(binding);
 	return bindings[index];
 }

 uint8_t* DescriptorSetLayout::getOffsetPointer(DescriptorSet *descriptorSet, uint32_t binding, uint32_t arrayElement, uint32_t count, size_t* typeSize) const
 {
 	uint32_t index = getBindingIndex(binding);
 	*typeSize = GetDescriptorSize(bindings[index].descriptorType);
 	size_t byteOffset = bindingOffsets[index] + (*typeSize * arrayElement);
 	ASSERT(((*typeSize * count) + byteOffset) <= getDescriptorSetDataSize()); // Make sure the operation will not go out of bounds
 	return &descriptorSet->data[byteOffset];
 }

 const uint8_t* DescriptorSetLayout::GetInputData(const VkWriteDescriptorSet& writeDescriptorSet)
 {
 	switch(writeDescriptorSet.descriptorType)
 	{
 	case VK_DESCRIPTOR_TYPE_SAMPLER:
 	case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
 	case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
 	case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
 	case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
 		return reinterpret_cast<const uint8_t*>(writeDescriptorSet.pImageInfo);
 	case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
 	case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
 		return reinterpret_cast<const uint8_t*>(writeDescriptorSet.pTexelBufferView);
 		break;
 	case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
 	case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
 	case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
 	case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
 		return reinterpret_cast<const uint8_t*>(writeDescriptorSet.pBufferInfo);
 		break;
 	default:
 		UNIMPLEMENTED("descriptorType");
 		return nullptr;
 	}
 }

 void DescriptorSetLayout::WriteDescriptorSet(const VkWriteDescriptorSet& writeDescriptorSet)
 {
 	DescriptorSet* dstSet = vk::Cast(writeDescriptorSet.dstSet);
 	DescriptorSetLayout* dstLayout = dstSet->layout;
 	ASSERT(dstLayout);
 	ASSERT(dstLayout->bindings[dstLayout->getBindingIndex(writeDescriptorSet.dstBinding)].descriptorType == writeDescriptorSet.descriptorType);

 	size_t typeSize = 0;
 	uint8_t* memToWrite = dstLayout->getOffsetPointer(dstSet, writeDescriptorSet.dstBinding, writeDescriptorSet.dstArrayElement, writeDescriptorSet.descriptorCount, &typeSize);

 	if(writeDescriptorSet.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
 	{
 		SampledImageDescriptor *imageSampler = reinterpret_cast<SampledImageDescriptor*>(memToWrite);

 		for(uint32_t i = 0; i < writeDescriptorSet.descriptorCount; i++)
 		{
 			vk::Sampler *sampler = vk::Cast(writeDescriptorSet.pImageInfo[i].sampler);
 			vk::ImageView *imageView = vk::Cast(writeDescriptorSet.pImageInfo[i].imageView);

 			imageSampler[i].sampler = sampler;
 			imageSampler[i].imageView = imageView;

 			sw::Texture *texture = &imageSampler[i].texture;
 			memset(texture, 0, sizeof(sw::Texture));  // TODO(b/129523279): eliminate

 			auto &subresourceRange = imageView->getSubresourceRange();
 			int baseLevel = subresourceRange.baseMipLevel;

 			for(int mipmapLevel = 0; mipmapLevel < sw::MIPMAP_LEVELS; mipmapLevel++)
 			{
 				int level = mipmapLevel - baseLevel;  // Level within the image view
 				level = sw::clamp(level, 0, (int)subresourceRange.levelCount);

 				VkOffset3D offset = {0, 0, 0};
 				VkImageAspectFlagBits aspect = VK_IMAGE_ASPECT_COLOR_BIT;
 				void *buffer = imageView->getOffsetPointer(offset, aspect);

 				sw::Mipmap &mipmap = texture->mipmap[mipmapLevel];
 				mipmap.buffer[0] = buffer;

 				VkExtent3D extent = imageView->getMipLevelExtent(level);
 				Format format = imageView->getFormat();
 				int width = extent.width;
 				int height = extent.height;
 				int depth = extent.depth;
 				int pitchP = imageView->rowPitchBytes(aspect, level) / format.bytes();
 				int sliceP = imageView->slicePitchBytes(aspect, level) / format.bytes();

 				float exp2LOD = 1.0f;

 				if(mipmapLevel == 0)
 				{
 					texture->widthHeightLOD[0] = width * exp2LOD;
 					texture->widthHeightLOD[1] = width * exp2LOD;
 					texture->widthHeightLOD[2] = height * exp2LOD;
 					texture->widthHeightLOD[3] = height * exp2LOD;

 					texture->widthLOD[0] = width * exp2LOD;
 					texture->widthLOD[1] = width * exp2LOD;
 					texture->widthLOD[2] = width * exp2LOD;
 					texture->widthLOD[3] = width * exp2LOD;

 					texture->heightLOD[0] = height * exp2LOD;
 					texture->heightLOD[1] = height * exp2LOD;
 					texture->heightLOD[2] = height * exp2LOD;
 					texture->heightLOD[3] = height * exp2LOD;

 					texture->depthLOD[0] = depth * exp2LOD;
 					texture->depthLOD[1] = depth * exp2LOD;
 					texture->depthLOD[2] = depth * exp2LOD;
 					texture->depthLOD[3] = depth * exp2LOD;
 				}

 				if(format.isFloatFormat())
 				{
 					mipmap.fWidth[0] = (float)width / 65536.0f;
 					mipmap.fWidth[1] = (float)width / 65536.0f;
 					mipmap.fWidth[2] = (float)width / 65536.0f;
 					mipmap.fWidth[3] = (float)width / 65536.0f;

 					mipmap.fHeight[0] = (float)height / 65536.0f;
 					mipmap.fHeight[1] = (float)height / 65536.0f;
 					mipmap.fHeight[2] = (float)height / 65536.0f;
 					mipmap.fHeight[3] = (float)height / 65536.0f;

 					mipmap.fDepth[0] = (float)depth / 65536.0f;
 					mipmap.fDepth[1] = (float)depth / 65536.0f;
 					mipmap.fDepth[2] = (float)depth / 65536.0f;
 					mipmap.fDepth[3] = (float)depth / 65536.0f;
 				}

 				short halfTexelU = 0x8000 / width;
 				short halfTexelV = 0x8000 / height;
 				short halfTexelW = 0x8000 / depth;

 				mipmap.uHalf[0] = halfTexelU;
 				mipmap.uHalf[1] = halfTexelU;
 				mipmap.uHalf[2] = halfTexelU;
 				mipmap.uHalf[3] = halfTexelU;

 				mipmap.vHalf[0] = halfTexelV;
 				mipmap.vHalf[1] = halfTexelV;
 				mipmap.vHalf[2] = halfTexelV;
 				mipmap.vHalf[3] = halfTexelV;

 				mipmap.wHalf[0] = halfTexelW;
 				mipmap.wHalf[1] = halfTexelW;
 				mipmap.wHalf[2] = halfTexelW;
 				mipmap.wHalf[3] = halfTexelW;

 				mipmap.width[0] = width;
 				mipmap.width[1] = width;
 				mipmap.width[2] = width;
 				mipmap.width[3] = width;

 				mipmap.height[0] = height;
 				mipmap.height[1] = height;
 				mipmap.height[2] = height;
 				mipmap.height[3] = height;

 				mipmap.depth[0] = depth;
 				mipmap.depth[1] = depth;
 				mipmap.depth[2] = depth;
 				mipmap.depth[3] = depth;

 				mipmap.onePitchP[0] = 1;
 				mipmap.onePitchP[1] = pitchP;
 				mipmap.onePitchP[2] = 1;
 				mipmap.onePitchP[3] = pitchP;

 				mipmap.pitchP[0] = pitchP;
 				mipmap.pitchP[1] = pitchP;
 				mipmap.pitchP[2] = pitchP;
 				mipmap.pitchP[3] = pitchP;

 				mipmap.sliceP[0] = sliceP;
 				mipmap.sliceP[1] = sliceP;
 				mipmap.sliceP[2] = sliceP;
 				mipmap.sliceP[3] = sliceP;

 				// TODO(b/129523279)
 				if(false/*format == FORMAT_YV12_BT601 ||
 				   format == FORMAT_YV12_BT709 ||
 				   format == FORMAT_YV12_JFIF*/)
 				{
 					unsigned int YStride = pitchP;
 					unsigned int YSize = YStride * height;
 					unsigned int CStride = sw::align<16>(YStride / 2);
 					unsigned int CSize = CStride * height / 2;

 					mipmap.buffer[1] = (sw::byte*)mipmap.buffer[0] + YSize;
 					mipmap.buffer[2] = (sw::byte*)mipmap.buffer[1] + CSize;

 					texture->mipmap[1].width[0] = width / 2;
 					texture->mipmap[1].width[1] = width / 2;
 					texture->mipmap[1].width[2] = width / 2;
 					texture->mipmap[1].width[3] = width / 2;
 					texture->mipmap[1].height[0] = height / 2;
 					texture->mipmap[1].height[1] = height / 2;
 					texture->mipmap[1].height[2] = height / 2;
 					texture->mipmap[1].height[3] = height / 2;
 					texture->mipmap[1].onePitchP[0] = 1;
 					texture->mipmap[1].onePitchP[1] = CStride;
 					texture->mipmap[1].onePitchP[2] = 1;
 					texture->mipmap[1].onePitchP[3] = CStride;
 				}
 			}
 		}
 	}
 	else
 	{
 		// If the dstBinding has fewer than descriptorCount array elements remaining
 		// starting from dstArrayElement, then the remainder will be used to update
 		// the subsequent binding - dstBinding+1 starting at array element zero. If
 		// a binding has a descriptorCount of zero, it is skipped. This behavior
 		// applies recursively, with the update affecting consecutive bindings as
 		// needed to update all descriptorCount descriptors.
 		size_t writeSize = typeSize * writeDescriptorSet.descriptorCount;
 		memcpy(memToWrite, DescriptorSetLayout::GetInputData(writeDescriptorSet), writeSize);
 	}
 }

 void DescriptorSetLayout::CopyDescriptorSet(const VkCopyDescriptorSet& descriptorCopies)
 {
 	DescriptorSet* srcSet = vk::Cast(descriptorCopies.srcSet);
 	DescriptorSetLayout* srcLayout = srcSet->layout;
 	ASSERT(srcLayout);

 	DescriptorSet* dstSet = vk::Cast(descriptorCopies.dstSet);
 	DescriptorSetLayout* dstLayout = dstSet->layout;
 	ASSERT(dstLayout);

 	size_t srcTypeSize = 0;
 	uint8_t* memToRead = srcLayout->getOffsetPointer(srcSet, descriptorCopies.srcBinding, descriptorCopies.srcArrayElement, descriptorCopies.descriptorCount, &srcTypeSize);

 	size_t dstTypeSize = 0;
 	uint8_t* memToWrite = dstLayout->getOffsetPointer(dstSet, descriptorCopies.dstBinding, descriptorCopies.dstArrayElement, descriptorCopies.descriptorCount, &dstTypeSize);

 	ASSERT(srcTypeSize == dstTypeSize);
 	size_t writeSize = dstTypeSize * descriptorCopies.descriptorCount;
 	memcpy(memToWrite, memToRead, writeSize);
 }

 } // namespace vk
	// Copyright 2018 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 "VkDescriptorSetLayout.hpp"

	#include "VkDescriptorSet.hpp"
	#include "VkSampler.hpp"
	#include "VkImageView.hpp"
	#include "System/Types.hpp"

	#include <algorithm>
	#include <cstring>

	namespace
	{

	static bool UsesImmutableSamplers(const VkDescriptorSetLayoutBinding& binding)
	{
	return (((binding.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) \|\|
	(binding.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)) &&
	(binding.pImmutableSamplers != nullptr));
	}

	}

	namespace vk
	{

	DescriptorSetLayout::DescriptorSetLayout(const VkDescriptorSetLayoutCreateInfo* pCreateInfo, void* mem) :
	flags(pCreateInfo->flags), bindingCount(pCreateInfo->bindingCount), bindings(reinterpret_cast<VkDescriptorSetLayoutBinding*>(mem))
	{
	uint8_t* hostMemory = static_cast<uint8_t>(mem) + bindingCount sizeof(VkDescriptorSetLayoutBinding);
	bindingOffsets = reinterpret_cast<size_t*>(hostMemory);
	hostMemory += bindingCount * sizeof(size_t);

	size_t offset = 0;
	for(uint32_t i = 0; i < bindingCount; i++)
	{
	bindings[i] = pCreateInfo->pBindings[i];
	if(UsesImmutableSamplers(bindings[i]))
	{
	size_t immutableSamplersSize = bindings[i].descriptorCount * sizeof(VkSampler);
	bindings[i].pImmutableSamplers = reinterpret_cast<const VkSampler*>(hostMemory);
	hostMemory += immutableSamplersSize;
	memcpy(const_cast<VkSampler*>(bindings[i].pImmutableSamplers),
	pCreateInfo->pBindings[i].pImmutableSamplers,
	immutableSamplersSize);
	}
	else
	{
	bindings[i].pImmutableSamplers = nullptr;
	}
	bindingOffsets[i] = offset;
	offset += bindings[i].descriptorCount * GetDescriptorSize(bindings[i].descriptorType);
	}
	}

	void DescriptorSetLayout::destroy(const VkAllocationCallbacks* pAllocator)
	{
	vk::deallocate(bindings, pAllocator); // This allocation also contains pImmutableSamplers
	}

	size_t DescriptorSetLayout::ComputeRequiredAllocationSize(const VkDescriptorSetLayoutCreateInfo* pCreateInfo)
	{
	size_t allocationSize = pCreateInfo->bindingCount * (sizeof(VkDescriptorSetLayoutBinding) + sizeof(size_t));

	for(uint32_t i = 0; i < pCreateInfo->bindingCount; i++)
	{
	if(UsesImmutableSamplers(pCreateInfo->pBindings[i]))
	{
	allocationSize += pCreateInfo->pBindings[i].descriptorCount * sizeof(VkSampler);
	}
	}

	return allocationSize;
	}

	size_t DescriptorSetLayout::GetDescriptorSize(VkDescriptorType type)
	{
	switch(type)
	{
	case VK_DESCRIPTOR_TYPE_SAMPLER:
	case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
	case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
	return sizeof(SampledImageDescriptor);
	case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
	case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
	return sizeof(VkDescriptorImageInfo);
	case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
	case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
	return sizeof(VkBufferView);
	case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
	case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
	case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
	case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
	return sizeof(VkDescriptorBufferInfo);
	default:
	UNIMPLEMENTED("Unsupported Descriptor Type");
	}

	return 0;
	}

	size_t DescriptorSetLayout::getDescriptorSetAllocationSize() const
	{
	// vk::DescriptorSet has a layout member field.
	return sizeof(vk::DescriptorSetLayout*) + getDescriptorSetDataSize();
	}

	size_t DescriptorSetLayout::getDescriptorSetDataSize() const
	{
	size_t size = 0;
	for(uint32_t i = 0; i < bindingCount; i++)
	{
	size += bindings[i].descriptorCount * GetDescriptorSize(bindings[i].descriptorType);
	}

	return size;
	}

	uint32_t DescriptorSetLayout::getBindingIndex(uint32_t binding) const
	{
	for(uint32_t i = 0; i < bindingCount; i++)
	{
	if(binding == bindings[i].binding)
	{
	return i;
	}
	}

	DABORT("Invalid DescriptorSetLayout binding: %d", int(binding));
	return 0;
	}

	void DescriptorSetLayout::initialize(VkDescriptorSet vkDescriptorSet)
	{
	// Use a pointer to this descriptor set layout as the descriptor set's header
	DescriptorSet* descriptorSet = vk::Cast(vkDescriptorSet);
	descriptorSet->layout = this;
	uint8_t* mem = descriptorSet->data;

	for(uint32_t i = 0; i < bindingCount; i++)
	{
	size_t typeSize = GetDescriptorSize(bindings[i].descriptorType);
	if(UsesImmutableSamplers(bindings[i]))
	{
	for(uint32_t j = 0; j < bindings[i].descriptorCount; j++)
	{
	SampledImageDescriptor* imageSamplerDescriptor = reinterpret_cast<SampledImageDescriptor*>(mem);
	imageSamplerDescriptor->sampler = vk::Cast(bindings[i].pImmutableSamplers[j]);
	mem += typeSize;
	}
	}
	else
	{
	mem += bindings[i].descriptorCount * typeSize;
	}
	}
	}

	size_t DescriptorSetLayout::getBindingCount() const
	{
	return bindingCount;
	}

	size_t DescriptorSetLayout::getBindingOffset(uint32_t binding, size_t arrayElement) const
	{
	uint32_t index = getBindingIndex(binding);
	auto typeSize = GetDescriptorSize(bindings[index].descriptorType);
	return bindingOffsets[index] + OFFSET(DescriptorSet, data[0]) + (typeSize * arrayElement);
	}

	bool DescriptorSetLayout::isDynamic(VkDescriptorType type)
	{
	return type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC \|\|
	type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
	}

	bool DescriptorSetLayout::isBindingDynamic(uint32_t binding) const
	{
	uint32_t index = getBindingIndex(binding);
	return isDynamic(bindings[index].descriptorType);
	}

	uint32_t DescriptorSetLayout::getDynamicDescriptorCount() const
	{
	uint32_t count = 0;
	for (size_t i = 0; i < bindingCount; i++)
	{
	if (isDynamic(bindings[i].descriptorType))
	{
	count += bindings[i].descriptorCount;
	}
	}
	return count;
	}

	uint32_t DescriptorSetLayout::getDynamicDescriptorOffset(uint32_t binding) const
	{
	uint32_t n = getBindingIndex(binding);
	ASSERT(isDynamic(bindings[n].descriptorType));

	uint32_t index = 0;
	for (uint32_t i = 0; i < n; i++)
	{
	if (isDynamic(bindings[i].descriptorType))
	{
	index += bindings[i].descriptorCount;
	}
	}
	return index;
	}

	VkDescriptorSetLayoutBinding const & DescriptorSetLayout::getBindingLayout(uint32_t binding) const
	{
	uint32_t index = getBindingIndex(binding);
	return bindings[index];
	}

	uint8_t* DescriptorSetLayout::getOffsetPointer(DescriptorSet descriptorSet, uint32_t binding, uint32_t arrayElement, uint32_t count, size_t typeSize) const
	{
	uint32_t index = getBindingIndex(binding);
	*typeSize = GetDescriptorSize(bindings[index].descriptorType);
	size_t byteOffset = bindingOffsets[index] + (typeSize arrayElement);
	ASSERT(((typeSize count) + byteOffset) <= getDescriptorSetDataSize()); // Make sure the operation will not go out of bounds
	return &descriptorSet->data[byteOffset];
	}

	const uint8_t* DescriptorSetLayout::GetInputData(const VkWriteDescriptorSet& writeDescriptorSet)
	{
	switch(writeDescriptorSet.descriptorType)
	{
	case VK_DESCRIPTOR_TYPE_SAMPLER:
	case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
	case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
	case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
	case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
	return reinterpret_cast<const uint8_t*>(writeDescriptorSet.pImageInfo);
	case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
	case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
	return reinterpret_cast<const uint8_t*>(writeDescriptorSet.pTexelBufferView);
	break;
	case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
	case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
	case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
	case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
	return reinterpret_cast<const uint8_t*>(writeDescriptorSet.pBufferInfo);
	break;
	default:
	UNIMPLEMENTED("descriptorType");
	return nullptr;
	}
	}

	void DescriptorSetLayout::WriteDescriptorSet(const VkWriteDescriptorSet& writeDescriptorSet)
	{
	DescriptorSet* dstSet = vk::Cast(writeDescriptorSet.dstSet);
	DescriptorSetLayout* dstLayout = dstSet->layout;
	ASSERT(dstLayout);
	ASSERT(dstLayout->bindings[dstLayout->getBindingIndex(writeDescriptorSet.dstBinding)].descriptorType == writeDescriptorSet.descriptorType);

	size_t typeSize = 0;
	uint8_t* memToWrite = dstLayout->getOffsetPointer(dstSet, writeDescriptorSet.dstBinding, writeDescriptorSet.dstArrayElement, writeDescriptorSet.descriptorCount, &typeSize);

	if(writeDescriptorSet.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
	{
	SampledImageDescriptor imageSampler = reinterpret_cast<SampledImageDescriptor>(memToWrite);

	for(uint32_t i = 0; i < writeDescriptorSet.descriptorCount; i++)
	{
	vk::Sampler *sampler = vk::Cast(writeDescriptorSet.pImageInfo[i].sampler);
	vk::ImageView *imageView = vk::Cast(writeDescriptorSet.pImageInfo[i].imageView);

	imageSampler[i].sampler = sampler;
	imageSampler[i].imageView = imageView;

	sw::Texture *texture = &imageSampler[i].texture;
	memset(texture, 0, sizeof(sw::Texture)); // TODO(b/129523279): eliminate

	auto &subresourceRange = imageView->getSubresourceRange();
	int baseLevel = subresourceRange.baseMipLevel;

	for(int mipmapLevel = 0; mipmapLevel < sw::MIPMAP_LEVELS; mipmapLevel++)
	{
	int level = mipmapLevel - baseLevel; // Level within the image view
	level = sw::clamp(level, 0, (int)subresourceRange.levelCount);

	VkOffset3D offset = {0, 0, 0};
	VkImageAspectFlagBits aspect = VK_IMAGE_ASPECT_COLOR_BIT;
	void *buffer = imageView->getOffsetPointer(offset, aspect);

	sw::Mipmap &mipmap = texture->mipmap[mipmapLevel];
	mipmap.buffer[0] = buffer;

	VkExtent3D extent = imageView->getMipLevelExtent(level);
	Format format = imageView->getFormat();
	int width = extent.width;
	int height = extent.height;
	int depth = extent.depth;
	int pitchP = imageView->rowPitchBytes(aspect, level) / format.bytes();
	int sliceP = imageView->slicePitchBytes(aspect, level) / format.bytes();

	float exp2LOD = 1.0f;

	if(mipmapLevel == 0)
	{
	texture->widthHeightLOD[0] = width * exp2LOD;
	texture->widthHeightLOD[1] = width * exp2LOD;
	texture->widthHeightLOD[2] = height * exp2LOD;
	texture->widthHeightLOD[3] = height * exp2LOD;

	texture->widthLOD[0] = width * exp2LOD;
	texture->widthLOD[1] = width * exp2LOD;
	texture->widthLOD[2] = width * exp2LOD;
	texture->widthLOD[3] = width * exp2LOD;

	texture->heightLOD[0] = height * exp2LOD;
	texture->heightLOD[1] = height * exp2LOD;
	texture->heightLOD[2] = height * exp2LOD;
	texture->heightLOD[3] = height * exp2LOD;

	texture->depthLOD[0] = depth * exp2LOD;
	texture->depthLOD[1] = depth * exp2LOD;
	texture->depthLOD[2] = depth * exp2LOD;
	texture->depthLOD[3] = depth * exp2LOD;
	}

	if(format.isFloatFormat())
	{
	mipmap.fWidth[0] = (float)width / 65536.0f;
	mipmap.fWidth[1] = (float)width / 65536.0f;
	mipmap.fWidth[2] = (float)width / 65536.0f;
	mipmap.fWidth[3] = (float)width / 65536.0f;

	mipmap.fHeight[0] = (float)height / 65536.0f;
	mipmap.fHeight[1] = (float)height / 65536.0f;
	mipmap.fHeight[2] = (float)height / 65536.0f;
	mipmap.fHeight[3] = (float)height / 65536.0f;

	mipmap.fDepth[0] = (float)depth / 65536.0f;
	mipmap.fDepth[1] = (float)depth / 65536.0f;
	mipmap.fDepth[2] = (float)depth / 65536.0f;
	mipmap.fDepth[3] = (float)depth / 65536.0f;
	}

	short halfTexelU = 0x8000 / width;
	short halfTexelV = 0x8000 / height;
	short halfTexelW = 0x8000 / depth;

	mipmap.uHalf[0] = halfTexelU;
	mipmap.uHalf[1] = halfTexelU;
	mipmap.uHalf[2] = halfTexelU;
	mipmap.uHalf[3] = halfTexelU;

	mipmap.vHalf[0] = halfTexelV;
	mipmap.vHalf[1] = halfTexelV;
	mipmap.vHalf[2] = halfTexelV;
	mipmap.vHalf[3] = halfTexelV;

	mipmap.wHalf[0] = halfTexelW;
	mipmap.wHalf[1] = halfTexelW;
	mipmap.wHalf[2] = halfTexelW;
	mipmap.wHalf[3] = halfTexelW;

	mipmap.width[0] = width;
	mipmap.width[1] = width;
	mipmap.width[2] = width;
	mipmap.width[3] = width;

	mipmap.height[0] = height;
	mipmap.height[1] = height;
	mipmap.height[2] = height;
	mipmap.height[3] = height;

	mipmap.depth[0] = depth;
	mipmap.depth[1] = depth;
	mipmap.depth[2] = depth;
	mipmap.depth[3] = depth;

	mipmap.onePitchP[0] = 1;
	mipmap.onePitchP[1] = pitchP;
	mipmap.onePitchP[2] = 1;
	mipmap.onePitchP[3] = pitchP;

	mipmap.pitchP[0] = pitchP;
	mipmap.pitchP[1] = pitchP;
	mipmap.pitchP[2] = pitchP;
	mipmap.pitchP[3] = pitchP;

	mipmap.sliceP[0] = sliceP;
	mipmap.sliceP[1] = sliceP;
	mipmap.sliceP[2] = sliceP;
	mipmap.sliceP[3] = sliceP;

	// TODO(b/129523279)
	if(false/*format == FORMAT_YV12_BT601 \|\|
	format == FORMAT_YV12_BT709 \|\|
	format == FORMAT_YV12_JFIF*/)
	{
	unsigned int YStride = pitchP;
	unsigned int YSize = YStride * height;
	unsigned int CStride = sw::align<16>(YStride / 2);
	unsigned int CSize = CStride * height / 2;

	mipmap.buffer[1] = (sw::byte*)mipmap.buffer[0] + YSize;
	mipmap.buffer[2] = (sw::byte*)mipmap.buffer[1] + CSize;

	texture->mipmap[1].width[0] = width / 2;
	texture->mipmap[1].width[1] = width / 2;
	texture->mipmap[1].width[2] = width / 2;
	texture->mipmap[1].width[3] = width / 2;
	texture->mipmap[1].height[0] = height / 2;
	texture->mipmap[1].height[1] = height / 2;
	texture->mipmap[1].height[2] = height / 2;
	texture->mipmap[1].height[3] = height / 2;
	texture->mipmap[1].onePitchP[0] = 1;
	texture->mipmap[1].onePitchP[1] = CStride;
	texture->mipmap[1].onePitchP[2] = 1;
	texture->mipmap[1].onePitchP[3] = CStride;
	}
	}
	}
	}
	else
	{
	// If the dstBinding has fewer than descriptorCount array elements remaining
	// starting from dstArrayElement, then the remainder will be used to update
	// the subsequent binding - dstBinding+1 starting at array element zero. If
	// a binding has a descriptorCount of zero, it is skipped. This behavior
	// applies recursively, with the update affecting consecutive bindings as
	// needed to update all descriptorCount descriptors.
	size_t writeSize = typeSize * writeDescriptorSet.descriptorCount;
	memcpy(memToWrite, DescriptorSetLayout::GetInputData(writeDescriptorSet), writeSize);
	}
	}

	void DescriptorSetLayout::CopyDescriptorSet(const VkCopyDescriptorSet& descriptorCopies)
	{
	DescriptorSet* srcSet = vk::Cast(descriptorCopies.srcSet);
	DescriptorSetLayout* srcLayout = srcSet->layout;
	ASSERT(srcLayout);

	DescriptorSet* dstSet = vk::Cast(descriptorCopies.dstSet);
	DescriptorSetLayout* dstLayout = dstSet->layout;
	ASSERT(dstLayout);

	size_t srcTypeSize = 0;
	uint8_t* memToRead = srcLayout->getOffsetPointer(srcSet, descriptorCopies.srcBinding, descriptorCopies.srcArrayElement, descriptorCopies.descriptorCount, &srcTypeSize);

	size_t dstTypeSize = 0;
	uint8_t* memToWrite = dstLayout->getOffsetPointer(dstSet, descriptorCopies.dstBinding, descriptorCopies.dstArrayElement, descriptorCopies.descriptorCount, &dstTypeSize);

	ASSERT(srcTypeSize == dstTypeSize);
	size_t writeSize = dstTypeSize * descriptorCopies.descriptorCount;
	memcpy(memToWrite, memToRead, writeSize);
	}

	} // namespace vk