src/dawn/utils/WGPUHelpers.cpp - dawn - Git at Google


            
            // Copyright 2017 The Dawn & Tint Authors

            
            //

            
            // Redistribution and use in source and binary forms, with or without

            
            // modification, are permitted provided that the following conditions are met:

            
            //

            
            // 1. Redistributions of source code must retain the above copyright notice, this

            
            //    list of conditions and the following disclaimer.

            
            //

            
            // 2. Redistributions in binary form must reproduce the above copyright notice,

            
            //    this list of conditions and the following disclaimer in the documentation

            
            //    and/or other materials provided with the distribution.

            
            //

            
            // 3. Neither the name of the copyright holder nor the names of its

            
            //    contributors may be used to endorse or promote products derived from

            
            //    this software without specific prior written permission.

            
            //

            
            // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

            
            // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

            
            // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

            
            // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

            
            // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

            
            // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

            
            // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

            
            // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

            
            // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

            
            // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


            #include "dawn/utils/WGPUHelpers.h"


            #include <cstring>

            
            #include <iomanip>

            
            #include <limits>

            
            #include <mutex>

            
            #include <sstream>


            #include "dawn/common/Constants.h"

            
            #include "dawn/common/Log.h"

            
            #include "dawn/common/Numeric.h"


            #if TINT_BUILD_SPV_READER

            
            #include "spirv-tools/optimizer.hpp"

            
            #endif


            namespace dawn::utils {

            
            #if TINT_BUILD_SPV_READER

            
            wgpu::ShaderModule CreateShaderModuleFromASM(

            
                const wgpu::Device& device,

            
                const char* source,

            
                wgpu::DawnShaderModuleSPIRVOptionsDescriptor* spirv_options) {

            
                // Use SPIRV-Tools's C API to assemble the SPIR-V assembly text to binary. Because the types

            
                // aren't RAII, we don't return directly on success and instead always go through the code

            
                // path that destroys the SPIRV-Tools objects.

            
                wgpu::ShaderModule result = nullptr;


                spv_context context = spvContextCreate(SPV_ENV_UNIVERSAL_1_3);

            
                DAWN_ASSERT(context != nullptr);


                spv_binary spirv = nullptr;

            
                spv_diagnostic diagnostic = nullptr;

            
                if (spvTextToBinary(context, source, strlen(source), &spirv, &diagnostic) == SPV_SUCCESS) {

            
                    DAWN_ASSERT(spirv != nullptr);

            
                    DAWN_ASSERT(spirv->wordCount <= std::numeric_limits<uint32_t>::max());


                    wgpu::ShaderSourceSPIRV spirvDesc;

            
                    spirvDesc.codeSize = static_cast<uint32_t>(spirv->wordCount);

            
                    spirvDesc.code = spirv->code;

            
                    spirvDesc.nextInChain = spirv_options;


                    wgpu::ShaderModuleDescriptor descriptor;

            
                    descriptor.nextInChain = &spirvDesc;

            
                    result = device.CreateShaderModule(&descriptor);

            
                } else {

            
                    DAWN_ASSERT(diagnostic != nullptr);

            
                    dawn::WarningLog() << "CreateShaderModuleFromASM SPIRV assembly error:"

            
                                       << diagnostic->position.line + 1 << ":"

            
                                       << diagnostic->position.column + 1 << ": " << diagnostic->error;

            
                }


                spvDiagnosticDestroy(diagnostic);

            
                spvBinaryDestroy(spirv);

            
                spvContextDestroy(context);


                return result;

            
            }

            
            #endif


            wgpu::ShaderModule CreateShaderModule(const wgpu::Device& device, const char* source) {

            
                wgpu::ShaderSourceWGSL wgslDesc;

            
                wgslDesc.code = source;

            
                wgpu::ShaderModuleDescriptor descriptor;

            
                descriptor.nextInChain = &wgslDesc;

            
                return device.CreateShaderModule(&descriptor);

            
            }


            wgpu::ShaderModule CreateShaderModule(const wgpu::Device& device, const std::string& source) {

            
                return CreateShaderModule(device, source.c_str());

            
            }


            wgpu::Buffer CreateBufferFromData(const wgpu::Device& device,

            
                                              const void* data,

            
                                              uint64_t size,

            
                                              wgpu::BufferUsage usage) {

            
                wgpu::BufferDescriptor descriptor;

            
                descriptor.size = size;

            
                descriptor.usage = usage | wgpu::BufferUsage::CopyDst;

            
                wgpu::Buffer buffer = device.CreateBuffer(&descriptor);


                device.GetQueue().WriteBuffer(buffer, 0, data, size);

            
                return buffer;

            
            }


            ComboRenderPassDescriptor::ComboRenderPassDescriptor(

            
                const std::vector<wgpu::TextureView>& colorAttachmentInfo,

            
                wgpu::TextureView depthStencil) {

            
                for (uint32_t i = 0; i < kMaxColorAttachments; ++i) {

            
                    cColorAttachments[i].loadOp = wgpu::LoadOp::Clear;

            
                    cColorAttachments[i].storeOp = wgpu::StoreOp::Store;

            
                    cColorAttachments[i].clearValue = {0.0f, 0.0f, 0.0f, 0.0f};

            
                }


                cDepthStencilAttachmentInfo.depthClearValue = 1.0f;

            
                cDepthStencilAttachmentInfo.stencilClearValue = 0;

            
                cDepthStencilAttachmentInfo.depthLoadOp = wgpu::LoadOp::Clear;

            
                cDepthStencilAttachmentInfo.depthStoreOp = wgpu::StoreOp::Store;

            
                cDepthStencilAttachmentInfo.stencilLoadOp = wgpu::LoadOp::Clear;

            
                cDepthStencilAttachmentInfo.stencilStoreOp = wgpu::StoreOp::Store;


                colorAttachmentCount = colorAttachmentInfo.size();

            
                uint32_t colorAttachmentIndex = 0;

            
                for (const wgpu::TextureView& colorAttachment : colorAttachmentInfo) {

            
                    if (colorAttachment.Get() != nullptr) {

            
                        cColorAttachments[colorAttachmentIndex].view = colorAttachment;

            
                    }

            
                    ++colorAttachmentIndex;

            
                }

            
                colorAttachments = cColorAttachments.data();


                if (depthStencil.Get() != nullptr) {

            
                    cDepthStencilAttachmentInfo.view = depthStencil;

            
                    depthStencilAttachment = &cDepthStencilAttachmentInfo;

            
                } else {

            
                    depthStencilAttachment = nullptr;

            
                }

            
            }


            ComboRenderPassDescriptor::~ComboRenderPassDescriptor() = default;


            ComboRenderPassDescriptor::ComboRenderPassDescriptor(const ComboRenderPassDescriptor& other) {

            
                *this = other;

            
            }


            const ComboRenderPassDescriptor& ComboRenderPassDescriptor::operator=(

            
                const ComboRenderPassDescriptor& otherRenderPass) {

            
                cDepthStencilAttachmentInfo = otherRenderPass.cDepthStencilAttachmentInfo;

            
                cColorAttachments = otherRenderPass.cColorAttachments;

            
                colorAttachmentCount = otherRenderPass.colorAttachmentCount;


                colorAttachments = cColorAttachments.data();


                if (otherRenderPass.depthStencilAttachment != nullptr) {

            
                    // Assign desc.depthStencilAttachment to this->depthStencilAttachmentInfo;

            
                    depthStencilAttachment = &cDepthStencilAttachmentInfo;

            
                } else {

            
                    depthStencilAttachment = nullptr;

            
                }


                return *this;

            
            }

            
            void ComboRenderPassDescriptor::UnsetDepthStencilLoadStoreOpsForFormat(wgpu::TextureFormat format) {

            
                switch (format) {

            
                    case wgpu::TextureFormat::Depth24Plus:

            
                    case wgpu::TextureFormat::Depth32Float:

            
                    case wgpu::TextureFormat::Depth16Unorm:

            
                        cDepthStencilAttachmentInfo.stencilLoadOp = wgpu::LoadOp::Undefined;

            
                        cDepthStencilAttachmentInfo.stencilStoreOp = wgpu::StoreOp::Undefined;

            
                        break;

            
                    case wgpu::TextureFormat::Stencil8:

            
                        cDepthStencilAttachmentInfo.depthLoadOp = wgpu::LoadOp::Undefined;

            
                        cDepthStencilAttachmentInfo.depthStoreOp = wgpu::StoreOp::Undefined;

            
                        break;

            
                    default:

            
                        break;

            
                }

            
            }


            BasicRenderPass::BasicRenderPass()

            
                : width(0),

            
                  height(0),

            
                  color(nullptr),

            
                  colorFormat(wgpu::TextureFormat::RGBA8Unorm),

            
                  renderPassInfo() {}


            BasicRenderPass::BasicRenderPass(uint32_t texWidth,

            
                                             uint32_t texHeight,

            
                                             wgpu::Texture colorAttachment,

            
                                             wgpu::TextureFormat textureFormat)

            
                : width(texWidth),

            
                  height(texHeight),

            
                  color(colorAttachment),

            
                  colorFormat(textureFormat),

            
                  renderPassInfo({colorAttachment.CreateView()}) {}


            BasicRenderPass CreateBasicRenderPass(const wgpu::Device& device,

            
                                                  uint32_t width,

            
                                                  uint32_t height,

            
                                                  wgpu::TextureFormat format) {

            
                DAWN_ASSERT(width > 0 && height > 0);


                wgpu::TextureDescriptor descriptor;

            
                descriptor.dimension = wgpu::TextureDimension::e2D;

            
                descriptor.size.width = width;

            
                descriptor.size.height = height;

            
                descriptor.size.depthOrArrayLayers = 1;

            
                descriptor.sampleCount = 1;

            
                descriptor.format = format;

            
                descriptor.mipLevelCount = 1;

            
                descriptor.usage = wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc;

            
                wgpu::Texture color = device.CreateTexture(&descriptor);


                return BasicRenderPass(width, height, color, format);

            
            }


            wgpu::ImageCopyBuffer CreateImageCopyBuffer(wgpu::Buffer buffer,

            
                                                        uint64_t offset,

            
                                                        uint32_t bytesPerRow,

            
                                                        uint32_t rowsPerImage) {

            
                wgpu::ImageCopyBuffer imageCopyBuffer = {};

            
                imageCopyBuffer.buffer = buffer;

            
                imageCopyBuffer.layout = CreateTextureDataLayout(offset, bytesPerRow, rowsPerImage);


                return imageCopyBuffer;

            
            }


            wgpu::ImageCopyTexture CreateImageCopyTexture(wgpu::Texture texture,

            
                                                          uint32_t mipLevel,

            
                                                          wgpu::Origin3D origin,

            
                                                          wgpu::TextureAspect aspect) {

            
                wgpu::ImageCopyTexture imageCopyTexture;

            
                imageCopyTexture.texture = texture;

            
                imageCopyTexture.mipLevel = mipLevel;

            
                imageCopyTexture.origin = origin;

            
                imageCopyTexture.aspect = aspect;


                return imageCopyTexture;

            
            }


            wgpu::TextureDataLayout CreateTextureDataLayout(uint64_t offset,

            
                                                            uint32_t bytesPerRow,

            
                                                            uint32_t rowsPerImage) {

            
                wgpu::TextureDataLayout textureDataLayout;

            
                textureDataLayout.offset = offset;

            
                textureDataLayout.bytesPerRow = bytesPerRow;

            
                textureDataLayout.rowsPerImage = rowsPerImage;


                return textureDataLayout;

            
            }


            wgpu::PipelineLayout MakeBasicPipelineLayout(const wgpu::Device& device,

            
                                                         const wgpu::BindGroupLayout* bindGroupLayout) {

            
                wgpu::PipelineLayoutDescriptor descriptor;

            
                if (bindGroupLayout != nullptr) {

            
                    descriptor.bindGroupLayoutCount = 1;

            
                    descriptor.bindGroupLayouts = bindGroupLayout;

            
                } else {

            
                    descriptor.bindGroupLayoutCount = 0;

            
                    descriptor.bindGroupLayouts = nullptr;

            
                }

            
                return device.CreatePipelineLayout(&descriptor);

            
            }


            wgpu::PipelineLayout MakePipelineLayout(const wgpu::Device& device,

            
                                                    std::vector<wgpu::BindGroupLayout> bgls) {

            
                wgpu::PipelineLayoutDescriptor descriptor;

            
                descriptor.bindGroupLayoutCount = uint32_t(bgls.size());

            
                descriptor.bindGroupLayouts = bgls.data();

            
                return device.CreatePipelineLayout(&descriptor);

            
            }


            wgpu::BindGroupLayout MakeBindGroupLayout(

            
                const wgpu::Device& device,

            
                std::initializer_list<BindingLayoutEntryInitializationHelper> entriesInitializer) {

            
                std::vector<wgpu::BindGroupLayoutEntry> entries;

            
                for (const BindingLayoutEntryInitializationHelper& entry : entriesInitializer) {

            
                    entries.push_back(entry);

            
                }


                wgpu::BindGroupLayoutDescriptor descriptor;

            
                descriptor.entryCount = entries.size();

            
                descriptor.entries = entries.data();

            
                return device.CreateBindGroupLayout(&descriptor);

            
            }


            BindingLayoutEntryInitializationHelper::BindingLayoutEntryInitializationHelper(

            
                uint32_t entryBinding,

            
                wgpu::ShaderStage entryVisibility,

            
                wgpu::BufferBindingType bufferType,

            
                bool bufferHasDynamicOffset,

            
                uint64_t bufferMinBindingSize) {

            
                binding = entryBinding;

            
                visibility = entryVisibility;

            
                buffer.type = bufferType;

            
                buffer.hasDynamicOffset = bufferHasDynamicOffset;

            
                buffer.minBindingSize = bufferMinBindingSize;

            
            }


            BindingLayoutEntryInitializationHelper::BindingLayoutEntryInitializationHelper(

            
                uint32_t entryBinding,

            
                wgpu::ShaderStage entryVisibility,

            
                wgpu::SamplerBindingType samplerType) {

            
                binding = entryBinding;

            
                visibility = entryVisibility;

            
                sampler.type = samplerType;

            
            }


            BindingLayoutEntryInitializationHelper::BindingLayoutEntryInitializationHelper(

            
                uint32_t entryBinding,

            
                wgpu::ShaderStage entryVisibility,

            
                wgpu::TextureSampleType textureSampleType,

            
                wgpu::TextureViewDimension textureViewDimension,

            
                bool textureMultisampled) {

            
                binding = entryBinding;

            
                visibility = entryVisibility;

            
                texture.sampleType = textureSampleType;

            
                texture.viewDimension = textureViewDimension;

            
                texture.multisampled = textureMultisampled;

            
            }


            BindingLayoutEntryInitializationHelper::BindingLayoutEntryInitializationHelper(

            
                uint32_t entryBinding,

            
                wgpu::ShaderStage entryVisibility,

            
                wgpu::StorageTextureAccess storageTextureAccess,

            
                wgpu::TextureFormat format,

            
                wgpu::TextureViewDimension textureViewDimension) {

            
                binding = entryBinding;

            
                visibility = entryVisibility;

            
                storageTexture.access = storageTextureAccess;

            
                storageTexture.format = format;

            
                storageTexture.viewDimension = textureViewDimension;

            
            }


            #ifndef __EMSCRIPTEN__

            
            // ExternalTextureBindingLayout never contains data, so just make one that can be reused instead

            
            // of declaring a new one every time it's needed.

            
            wgpu::ExternalTextureBindingLayout kExternalTextureBindingLayout = {};


            BindingLayoutEntryInitializationHelper::BindingLayoutEntryInitializationHelper(

            
                uint32_t entryBinding,

            
                wgpu::ShaderStage entryVisibility,

            
                wgpu::ExternalTextureBindingLayout* bindingLayout) {

            
                binding = entryBinding;

            
                visibility = entryVisibility;

            
                nextInChain = bindingLayout;

            
            }


            BindingInitializationHelper::BindingInitializationHelper(

            
                uint32_t binding,

            
                const wgpu::ExternalTexture& externalTexture)

            
                : binding(binding) {

            
                externalTextureBindingEntry.externalTexture = externalTexture;

            
            }

            
            #endif  // __EMSCRIPTEN__


            BindingLayoutEntryInitializationHelper::BindingLayoutEntryInitializationHelper(

            
                const wgpu::BindGroupLayoutEntry& entry)

            
                : wgpu::BindGroupLayoutEntry(entry) {}


            BindingInitializationHelper::BindingInitializationHelper(uint32_t binding,

            
                                                                     const wgpu::Sampler& sampler)

            
                : binding(binding), sampler(sampler) {}


            BindingInitializationHelper::BindingInitializationHelper(uint32_t binding,

            
                                                                     const wgpu::TextureView& textureView)

            
                : binding(binding), textureView(textureView) {}


            BindingInitializationHelper::BindingInitializationHelper(uint32_t binding,

            
                                                                     const wgpu::Buffer& buffer,

            
                                                                     uint64_t offset,

            
                                                                     uint64_t size)

            
                : binding(binding), buffer(buffer), offset(offset), size(size) {}


            BindingInitializationHelper::BindingInitializationHelper(const BindingInitializationHelper&) =

            
                default;


            BindingInitializationHelper::~BindingInitializationHelper() = default;


            wgpu::BindGroupEntry BindingInitializationHelper::GetAsBinding() const {

            
                wgpu::BindGroupEntry result;


                result.binding = binding;

            
                result.sampler = sampler;

            
                result.textureView = textureView;

            
                result.buffer = buffer;

            
                result.offset = offset;

            
                result.size = size;

            
            #ifndef __EMSCRIPTEN__

            
                if (externalTextureBindingEntry.externalTexture != nullptr) {

            
                    result.nextInChain = &externalTextureBindingEntry;

            
                }

            
            #endif  // __EMSCRIPTEN__


                return result;

            
            }


            wgpu::BindGroup MakeBindGroup(

            
                const wgpu::Device& device,

            
                const wgpu::BindGroupLayout& layout,

            
                std::initializer_list<BindingInitializationHelper> entriesInitializer) {

            
                std::vector<wgpu::BindGroupEntry> entries;

            
                for (const BindingInitializationHelper& helper : entriesInitializer) {

            
                    entries.push_back(helper.GetAsBinding());

            
                }


                wgpu::BindGroupDescriptor descriptor;

            
                descriptor.layout = layout;

            
                descriptor.entryCount = checked_cast<uint32_t>(entries.size());

            
                descriptor.entries = entries.data();


                return device.CreateBindGroup(&descriptor);

            
            }


            ColorSpaceConversionInfo GetYUVBT709ToRGBSRGBColorSpaceConversionInfo() {

            
                ColorSpaceConversionInfo info;

            
                info.yuvToRgbConversionMatrix = {1.164384f, 0.0f,       1.792741f,  -0.972945f,

            
                                                 1.164384f, -0.213249f, -0.532909f, 0.301483f,

            
                                                 1.164384f, 2.112402f,  0.0f,       -1.133402f};

            
                info.gamutConversionMatrix = {1.0f, 0.0f, 0.0f,  //

            
                                              0.0f, 1.0f, 0.0f,  //

            
                                              0.0f, 0.0f, 1.0f};

            
                info.srcTransferFunctionParameters = {2.2, 1.0 / 1.099, 0.099 / 1.099, 1 / 4.5, 0.081,

            
                                                      0.0, 0.0};

            
                info.dstTransferFunctionParameters = {1 / 2.4, 1.137119, 0.0, 12.92, 0.0031308, -0.055, 0.0};

            
                return info;

            
            }


            ColorSpaceConversionInfo GetNoopRGBColorSpaceConversionInfo() {

            
                ColorSpaceConversionInfo info;


                // YUV to RGB is not used as the data is RGB.

            
                info.yuvToRgbConversionMatrix = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

            
                // Identity gamut conversion matrix.

            
                info.gamutConversionMatrix = {1.0f, 0.0f, 0.0f,  //

            
                                              0.0f, 1.0f, 0.0f,  //

            
                                              0.0f, 0.0f, 1.0f};


                // Set A = G = 1 and everything else to 0 to turn the code below into pow(x, 1) which is x

            
                //

            
                //    if (abs(v) < params.D) {

            
                //        return sign(v) * (params.C * abs(v) + params.F);

            
                //    }

            
                //    return pow(A * x + B, G) + E

            
                //

            
                // Note that for some reason the order of the data is G A B C D E F

            
                info.srcTransferFunctionParameters = {1, 1, 0, 0, 0, 0, 0};

            
                info.dstTransferFunctionParameters = {1, 1, 0, 0, 0, 0, 0};


                return info;

            
            }


            bool BackendRequiresCompat(wgpu::BackendType backend) {

            
                switch (backend) {

            
                    case wgpu::BackendType::D3D12:

            
                    case wgpu::BackendType::Metal:

            
                    case wgpu::BackendType::Vulkan:

            
                    case wgpu::BackendType::WebGPU:

            
                    case wgpu::BackendType::Null:

            
                        return false;

            
                    case wgpu::BackendType::D3D11:

            
                    case wgpu::BackendType::OpenGL:

            
                    case wgpu::BackendType::OpenGLES:

            
                        return true;

            
                    case wgpu::BackendType::Undefined:

            
                        DAWN_UNREACHABLE();

            
                }

            
            }


            }  // namespace dawn::utils
	// Copyright 2017 The Dawn & Tint Authors
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are met:
	//
	// 1. Redistributions of source code must retain the above copyright notice, this
	// list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation
	// and/or other materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	#include "dawn/utils/WGPUHelpers.h"

	#include <cstring>
	#include <iomanip>
	#include <limits>
	#include <mutex>
	#include <sstream>

	#include "dawn/common/Constants.h"
	#include "dawn/common/Log.h"
	#include "dawn/common/Numeric.h"

	#if TINT_BUILD_SPV_READER
	#include "spirv-tools/optimizer.hpp"
	#endif

	namespace dawn::utils {
	#if TINT_BUILD_SPV_READER
	wgpu::ShaderModule CreateShaderModuleFromASM(
	const wgpu::Device& device,
	const char* source,
	wgpu::DawnShaderModuleSPIRVOptionsDescriptor* spirv_options) {
	// Use SPIRV-Tools's C API to assemble the SPIR-V assembly text to binary. Because the types
	// aren't RAII, we don't return directly on success and instead always go through the code
	// path that destroys the SPIRV-Tools objects.
	wgpu::ShaderModule result = nullptr;

	spv_context context = spvContextCreate(SPV_ENV_UNIVERSAL_1_3);
	DAWN_ASSERT(context != nullptr);

	spv_binary spirv = nullptr;
	spv_diagnostic diagnostic = nullptr;
	if (spvTextToBinary(context, source, strlen(source), &spirv, &diagnostic) == SPV_SUCCESS) {
	DAWN_ASSERT(spirv != nullptr);
	DAWN_ASSERT(spirv->wordCount <= std::numeric_limits<uint32_t>::max());

	wgpu::ShaderSourceSPIRV spirvDesc;
	spirvDesc.codeSize = static_cast<uint32_t>(spirv->wordCount);
	spirvDesc.code = spirv->code;
	spirvDesc.nextInChain = spirv_options;

	wgpu::ShaderModuleDescriptor descriptor;
	descriptor.nextInChain = &spirvDesc;
	result = device.CreateShaderModule(&descriptor);
	} else {
	DAWN_ASSERT(diagnostic != nullptr);
	dawn::WarningLog() << "CreateShaderModuleFromASM SPIRV assembly error:"
	<< diagnostic->position.line + 1 << ":"
	<< diagnostic->position.column + 1 << ": " << diagnostic->error;
	}

	spvDiagnosticDestroy(diagnostic);
	spvBinaryDestroy(spirv);
	spvContextDestroy(context);

	return result;
	}
	#endif

	wgpu::ShaderModule CreateShaderModule(const wgpu::Device& device, const char* source) {
	wgpu::ShaderSourceWGSL wgslDesc;
	wgslDesc.code = source;
	wgpu::ShaderModuleDescriptor descriptor;
	descriptor.nextInChain = &wgslDesc;
	return device.CreateShaderModule(&descriptor);
	}

	wgpu::ShaderModule CreateShaderModule(const wgpu::Device& device, const std::string& source) {
	return CreateShaderModule(device, source.c_str());
	}

	wgpu::Buffer CreateBufferFromData(const wgpu::Device& device,
	const void* data,
	uint64_t size,
	wgpu::BufferUsage usage) {
	wgpu::BufferDescriptor descriptor;
	descriptor.size = size;
	descriptor.usage = usage \| wgpu::BufferUsage::CopyDst;
	wgpu::Buffer buffer = device.CreateBuffer(&descriptor);

	device.GetQueue().WriteBuffer(buffer, 0, data, size);
	return buffer;
	}

	ComboRenderPassDescriptor::ComboRenderPassDescriptor(
	const std::vector<wgpu::TextureView>& colorAttachmentInfo,
	wgpu::TextureView depthStencil) {
	for (uint32_t i = 0; i < kMaxColorAttachments; ++i) {
	cColorAttachments[i].loadOp = wgpu::LoadOp::Clear;
	cColorAttachments[i].storeOp = wgpu::StoreOp::Store;
	cColorAttachments[i].clearValue = {0.0f, 0.0f, 0.0f, 0.0f};
	}

	cDepthStencilAttachmentInfo.depthClearValue = 1.0f;
	cDepthStencilAttachmentInfo.stencilClearValue = 0;
	cDepthStencilAttachmentInfo.depthLoadOp = wgpu::LoadOp::Clear;
	cDepthStencilAttachmentInfo.depthStoreOp = wgpu::StoreOp::Store;
	cDepthStencilAttachmentInfo.stencilLoadOp = wgpu::LoadOp::Clear;
	cDepthStencilAttachmentInfo.stencilStoreOp = wgpu::StoreOp::Store;

	colorAttachmentCount = colorAttachmentInfo.size();
	uint32_t colorAttachmentIndex = 0;
	for (const wgpu::TextureView& colorAttachment : colorAttachmentInfo) {
	if (colorAttachment.Get() != nullptr) {
	cColorAttachments[colorAttachmentIndex].view = colorAttachment;
	}
	++colorAttachmentIndex;
	}
	colorAttachments = cColorAttachments.data();

	if (depthStencil.Get() != nullptr) {
	cDepthStencilAttachmentInfo.view = depthStencil;
	depthStencilAttachment = &cDepthStencilAttachmentInfo;
	} else {
	depthStencilAttachment = nullptr;
	}
	}

	ComboRenderPassDescriptor::~ComboRenderPassDescriptor() = default;

	ComboRenderPassDescriptor::ComboRenderPassDescriptor(const ComboRenderPassDescriptor& other) {
	*this = other;
	}

	const ComboRenderPassDescriptor& ComboRenderPassDescriptor::operator=(
	const ComboRenderPassDescriptor& otherRenderPass) {
	cDepthStencilAttachmentInfo = otherRenderPass.cDepthStencilAttachmentInfo;
	cColorAttachments = otherRenderPass.cColorAttachments;
	colorAttachmentCount = otherRenderPass.colorAttachmentCount;

	colorAttachments = cColorAttachments.data();

	if (otherRenderPass.depthStencilAttachment != nullptr) {
	// Assign desc.depthStencilAttachment to this->depthStencilAttachmentInfo;
	depthStencilAttachment = &cDepthStencilAttachmentInfo;
	} else {
	depthStencilAttachment = nullptr;
	}

	return *this;
	}
	void ComboRenderPassDescriptor::UnsetDepthStencilLoadStoreOpsForFormat(wgpu::TextureFormat format) {
	switch (format) {
	case wgpu::TextureFormat::Depth24Plus:
	case wgpu::TextureFormat::Depth32Float:
	case wgpu::TextureFormat::Depth16Unorm:
	cDepthStencilAttachmentInfo.stencilLoadOp = wgpu::LoadOp::Undefined;
	cDepthStencilAttachmentInfo.stencilStoreOp = wgpu::StoreOp::Undefined;
	break;
	case wgpu::TextureFormat::Stencil8:
	cDepthStencilAttachmentInfo.depthLoadOp = wgpu::LoadOp::Undefined;
	cDepthStencilAttachmentInfo.depthStoreOp = wgpu::StoreOp::Undefined;
	break;
	default:
	break;
	}
	}

	BasicRenderPass::BasicRenderPass()
	: width(0),
	height(0),
	color(nullptr),
	colorFormat(wgpu::TextureFormat::RGBA8Unorm),
	renderPassInfo() {}

	BasicRenderPass::BasicRenderPass(uint32_t texWidth,
	uint32_t texHeight,
	wgpu::Texture colorAttachment,
	wgpu::TextureFormat textureFormat)
	: width(texWidth),
	height(texHeight),
	color(colorAttachment),
	colorFormat(textureFormat),
	renderPassInfo({colorAttachment.CreateView()}) {}

	BasicRenderPass CreateBasicRenderPass(const wgpu::Device& device,
	uint32_t width,
	uint32_t height,
	wgpu::TextureFormat format) {
	DAWN_ASSERT(width > 0 && height > 0);

	wgpu::TextureDescriptor descriptor;
	descriptor.dimension = wgpu::TextureDimension::e2D;
	descriptor.size.width = width;
	descriptor.size.height = height;
	descriptor.size.depthOrArrayLayers = 1;
	descriptor.sampleCount = 1;
	descriptor.format = format;
	descriptor.mipLevelCount = 1;
	descriptor.usage = wgpu::TextureUsage::RenderAttachment \| wgpu::TextureUsage::CopySrc;
	wgpu::Texture color = device.CreateTexture(&descriptor);

	return BasicRenderPass(width, height, color, format);
	}

	wgpu::ImageCopyBuffer CreateImageCopyBuffer(wgpu::Buffer buffer,
	uint64_t offset,
	uint32_t bytesPerRow,
	uint32_t rowsPerImage) {
	wgpu::ImageCopyBuffer imageCopyBuffer = {};
	imageCopyBuffer.buffer = buffer;
	imageCopyBuffer.layout = CreateTextureDataLayout(offset, bytesPerRow, rowsPerImage);

	return imageCopyBuffer;
	}

	wgpu::ImageCopyTexture CreateImageCopyTexture(wgpu::Texture texture,
	uint32_t mipLevel,
	wgpu::Origin3D origin,
	wgpu::TextureAspect aspect) {
	wgpu::ImageCopyTexture imageCopyTexture;
	imageCopyTexture.texture = texture;
	imageCopyTexture.mipLevel = mipLevel;
	imageCopyTexture.origin = origin;
	imageCopyTexture.aspect = aspect;

	return imageCopyTexture;
	}

	wgpu::TextureDataLayout CreateTextureDataLayout(uint64_t offset,
	uint32_t bytesPerRow,
	uint32_t rowsPerImage) {
	wgpu::TextureDataLayout textureDataLayout;
	textureDataLayout.offset = offset;
	textureDataLayout.bytesPerRow = bytesPerRow;
	textureDataLayout.rowsPerImage = rowsPerImage;

	return textureDataLayout;
	}

	wgpu::PipelineLayout MakeBasicPipelineLayout(const wgpu::Device& device,
	const wgpu::BindGroupLayout* bindGroupLayout) {
	wgpu::PipelineLayoutDescriptor descriptor;
	if (bindGroupLayout != nullptr) {
	descriptor.bindGroupLayoutCount = 1;
	descriptor.bindGroupLayouts = bindGroupLayout;
	} else {
	descriptor.bindGroupLayoutCount = 0;
	descriptor.bindGroupLayouts = nullptr;
	}
	return device.CreatePipelineLayout(&descriptor);
	}

	wgpu::PipelineLayout MakePipelineLayout(const wgpu::Device& device,
	std::vector<wgpu::BindGroupLayout> bgls) {
	wgpu::PipelineLayoutDescriptor descriptor;
	descriptor.bindGroupLayoutCount = uint32_t(bgls.size());
	descriptor.bindGroupLayouts = bgls.data();
	return device.CreatePipelineLayout(&descriptor);
	}

	wgpu::BindGroupLayout MakeBindGroupLayout(
	const wgpu::Device& device,
	std::initializer_list<BindingLayoutEntryInitializationHelper> entriesInitializer) {
	std::vector<wgpu::BindGroupLayoutEntry> entries;
	for (const BindingLayoutEntryInitializationHelper& entry : entriesInitializer) {
	entries.push_back(entry);
	}

	wgpu::BindGroupLayoutDescriptor descriptor;
	descriptor.entryCount = entries.size();
	descriptor.entries = entries.data();
	return device.CreateBindGroupLayout(&descriptor);
	}

	BindingLayoutEntryInitializationHelper::BindingLayoutEntryInitializationHelper(
	uint32_t entryBinding,
	wgpu::ShaderStage entryVisibility,
	wgpu::BufferBindingType bufferType,
	bool bufferHasDynamicOffset,
	uint64_t bufferMinBindingSize) {
	binding = entryBinding;
	visibility = entryVisibility;
	buffer.type = bufferType;
	buffer.hasDynamicOffset = bufferHasDynamicOffset;
	buffer.minBindingSize = bufferMinBindingSize;
	}

	BindingLayoutEntryInitializationHelper::BindingLayoutEntryInitializationHelper(
	uint32_t entryBinding,
	wgpu::ShaderStage entryVisibility,
	wgpu::SamplerBindingType samplerType) {
	binding = entryBinding;
	visibility = entryVisibility;
	sampler.type = samplerType;
	}

	BindingLayoutEntryInitializationHelper::BindingLayoutEntryInitializationHelper(
	uint32_t entryBinding,
	wgpu::ShaderStage entryVisibility,
	wgpu::TextureSampleType textureSampleType,
	wgpu::TextureViewDimension textureViewDimension,
	bool textureMultisampled) {
	binding = entryBinding;
	visibility = entryVisibility;
	texture.sampleType = textureSampleType;
	texture.viewDimension = textureViewDimension;
	texture.multisampled = textureMultisampled;
	}

	BindingLayoutEntryInitializationHelper::BindingLayoutEntryInitializationHelper(
	uint32_t entryBinding,
	wgpu::ShaderStage entryVisibility,
	wgpu::StorageTextureAccess storageTextureAccess,
	wgpu::TextureFormat format,
	wgpu::TextureViewDimension textureViewDimension) {
	binding = entryBinding;
	visibility = entryVisibility;
	storageTexture.access = storageTextureAccess;
	storageTexture.format = format;
	storageTexture.viewDimension = textureViewDimension;
	}

	#ifndef __EMSCRIPTEN__
	// ExternalTextureBindingLayout never contains data, so just make one that can be reused instead
	// of declaring a new one every time it's needed.
	wgpu::ExternalTextureBindingLayout kExternalTextureBindingLayout = {};

	BindingLayoutEntryInitializationHelper::BindingLayoutEntryInitializationHelper(
	uint32_t entryBinding,
	wgpu::ShaderStage entryVisibility,
	wgpu::ExternalTextureBindingLayout* bindingLayout) {
	binding = entryBinding;
	visibility = entryVisibility;
	nextInChain = bindingLayout;
	}

	BindingInitializationHelper::BindingInitializationHelper(
	uint32_t binding,
	const wgpu::ExternalTexture& externalTexture)
	: binding(binding) {
	externalTextureBindingEntry.externalTexture = externalTexture;
	}
	#endif // __EMSCRIPTEN__

	BindingLayoutEntryInitializationHelper::BindingLayoutEntryInitializationHelper(
	const wgpu::BindGroupLayoutEntry& entry)
	: wgpu::BindGroupLayoutEntry(entry) {}

	BindingInitializationHelper::BindingInitializationHelper(uint32_t binding,
	const wgpu::Sampler& sampler)
	: binding(binding), sampler(sampler) {}

	BindingInitializationHelper::BindingInitializationHelper(uint32_t binding,
	const wgpu::TextureView& textureView)
	: binding(binding), textureView(textureView) {}

	BindingInitializationHelper::BindingInitializationHelper(uint32_t binding,
	const wgpu::Buffer& buffer,
	uint64_t offset,
	uint64_t size)
	: binding(binding), buffer(buffer), offset(offset), size(size) {}

	BindingInitializationHelper::BindingInitializationHelper(const BindingInitializationHelper&) =
	default;

	BindingInitializationHelper::~BindingInitializationHelper() = default;

	wgpu::BindGroupEntry BindingInitializationHelper::GetAsBinding() const {
	wgpu::BindGroupEntry result;

	result.binding = binding;
	result.sampler = sampler;
	result.textureView = textureView;
	result.buffer = buffer;
	result.offset = offset;
	result.size = size;
	#ifndef __EMSCRIPTEN__
	if (externalTextureBindingEntry.externalTexture != nullptr) {
	result.nextInChain = &externalTextureBindingEntry;
	}
	#endif // __EMSCRIPTEN__

	return result;
	}

	wgpu::BindGroup MakeBindGroup(
	const wgpu::Device& device,
	const wgpu::BindGroupLayout& layout,
	std::initializer_list<BindingInitializationHelper> entriesInitializer) {
	std::vector<wgpu::BindGroupEntry> entries;
	for (const BindingInitializationHelper& helper : entriesInitializer) {
	entries.push_back(helper.GetAsBinding());
	}

	wgpu::BindGroupDescriptor descriptor;
	descriptor.layout = layout;
	descriptor.entryCount = checked_cast<uint32_t>(entries.size());
	descriptor.entries = entries.data();

	return device.CreateBindGroup(&descriptor);
	}

	ColorSpaceConversionInfo GetYUVBT709ToRGBSRGBColorSpaceConversionInfo() {
	ColorSpaceConversionInfo info;
	info.yuvToRgbConversionMatrix = {1.164384f, 0.0f, 1.792741f, -0.972945f,
	1.164384f, -0.213249f, -0.532909f, 0.301483f,
	1.164384f, 2.112402f, 0.0f, -1.133402f};
	info.gamutConversionMatrix = {1.0f, 0.0f, 0.0f, //
	0.0f, 1.0f, 0.0f, //
	0.0f, 0.0f, 1.0f};
	info.srcTransferFunctionParameters = {2.2, 1.0 / 1.099, 0.099 / 1.099, 1 / 4.5, 0.081,
	0.0, 0.0};
	info.dstTransferFunctionParameters = {1 / 2.4, 1.137119, 0.0, 12.92, 0.0031308, -0.055, 0.0};
	return info;
	}

	ColorSpaceConversionInfo GetNoopRGBColorSpaceConversionInfo() {
	ColorSpaceConversionInfo info;

	// YUV to RGB is not used as the data is RGB.
	info.yuvToRgbConversionMatrix = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
	// Identity gamut conversion matrix.
	info.gamutConversionMatrix = {1.0f, 0.0f, 0.0f, //
	0.0f, 1.0f, 0.0f, //
	0.0f, 0.0f, 1.0f};

	// Set A = G = 1 and everything else to 0 to turn the code below into pow(x, 1) which is x
	//
	// if (abs(v) < params.D) {
	// return sign(v) * (params.C * abs(v) + params.F);
	// }
	// return pow(A * x + B, G) + E
	//
	// Note that for some reason the order of the data is G A B C D E F
	info.srcTransferFunctionParameters = {1, 1, 0, 0, 0, 0, 0};
	info.dstTransferFunctionParameters = {1, 1, 0, 0, 0, 0, 0};

	return info;
	}

	bool BackendRequiresCompat(wgpu::BackendType backend) {
	switch (backend) {
	case wgpu::BackendType::D3D12:
	case wgpu::BackendType::Metal:
	case wgpu::BackendType::Vulkan:
	case wgpu::BackendType::WebGPU:
	case wgpu::BackendType::Null:
	return false;
	case wgpu::BackendType::D3D11:
	case wgpu::BackendType::OpenGL:
	case wgpu::BackendType::OpenGLES:
	return true;
	case wgpu::BackendType::Undefined:
	DAWN_UNREACHABLE();
	}
	}

	} // namespace dawn::utils