src/dawn/native/ApplyClearColorValueWithDrawHelper.cpp - dawn - Git at Google

 // Copyright 2022 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/native/ApplyClearColorValueWithDrawHelper.h"

 #include <limits>
 #include <string>
 #include <utility>
 #include <vector>

 #include "dawn/common/Enumerator.h"
 #include "dawn/common/Range.h"
 #include "dawn/native/BindGroup.h"
 #include "dawn/native/BindGroupLayout.h"
 #include "dawn/native/Device.h"
 #include "dawn/native/InternalPipelineStore.h"
 #include "dawn/native/ObjectContentHasher.h"
 #include "dawn/native/RenderPassEncoder.h"
 #include "dawn/native/RenderPipeline.h"
 #include "dawn/native/utils/WGPUHelpers.h"
 #include "dawn/native/webgpu_absl_format.h"

 namespace dawn::native {

 namespace {

 // General helper functions and data structures for applying clear values with draw
 static const char kVSSource[] = R"(
 @vertex
 fn main(@builtin(vertex_index) VertexIndex : u32) -> @builtin(position) vec4f {
     var pos = array(
         vec2f( 0.0, -1.0),
         vec2f( 1.0, -1.0),
         vec2f( 0.0,  1.0),
         vec2f( 0.0,  1.0),
         vec2f( 1.0, -1.0),
         vec2f( 1.0,  1.0));
         return vec4f(pos[VertexIndex], 0.0, 1.0);
 })";

 const char* GetTextureComponentTypeString(DeviceBase* device, wgpu::TextureFormat format) {
     DAWN_ASSERT(format != wgpu::TextureFormat::Undefined);

     const Format& formatInfo = device->GetValidInternalFormat(format);
     switch (formatInfo.GetAspectInfo(Aspect::Color).baseType) {
         case TextureComponentType::Sint:
             return "i32";
         case TextureComponentType::Uint:
             return "u32";
         case TextureComponentType::Float:
             break;
     }
     DAWN_UNREACHABLE();
 }

 // Construct the fragment shader to apply the input color values to the corresponding color
 // attachments of KeyOfApplyClearColorValueWithDrawPipelines.
 std::string ConstructFragmentShader(DeviceBase* device,
                                     const KeyOfApplyClearColorValueWithDrawPipelines& key) {
     std::ostringstream outputColorDeclarationStream;
     std::ostringstream clearValueUniformBufferDeclarationStream;
     std::ostringstream assignOutputColorStream;

     outputColorDeclarationStream << "struct OutputColor {" << std::endl;
     clearValueUniformBufferDeclarationStream << "struct ClearColors {" << std::endl;

     // Only generate the assignments we need.
     for (auto i : IterateBitSet(key.colorTargetsToApplyClearColorValue)) {
         wgpu::TextureFormat currentFormat = key.colorTargetFormats[i];
         DAWN_ASSERT(currentFormat != wgpu::TextureFormat::Undefined);

         const char* type = GetTextureComponentTypeString(device, currentFormat);

         outputColorDeclarationStream
             << absl::StrFormat("@location(%u) output%u : vec4<%s>,\n", i, i, type);
         clearValueUniformBufferDeclarationStream
             << absl::StrFormat("color%u : vec4<%s>,\n", i, type);
         assignOutputColorStream << absl::StrFormat("outputColor.output%u = clearColors.color%u;\n",
                                                    i, i);
     }
     outputColorDeclarationStream << "}" << std::endl;
     clearValueUniformBufferDeclarationStream << "}" << std::endl;

     std::ostringstream fragmentShaderStream;
     fragmentShaderStream << outputColorDeclarationStream.str()
                          << clearValueUniformBufferDeclarationStream.str() << R"(
 @group(0) @binding(0) var<uniform> clearColors : ClearColors;

 @fragment
 fn main() -> OutputColor {
     var outputColor : OutputColor;
 )" << assignOutputColorStream.str()
                          << R"(
 return outputColor;
 })";

     return fragmentShaderStream.str();
 }

 RenderPipelineBase* GetCachedPipeline(InternalPipelineStore* store,
                                       const KeyOfApplyClearColorValueWithDrawPipelines& key) {
     auto iter = store->applyClearColorValueWithDrawPipelines.find(key);
     if (iter != store->applyClearColorValueWithDrawPipelines.end()) {
         return iter->second.Get();
     }
     return nullptr;
 }

 ResultOrError<RenderPipelineBase*> GetOrCreateApplyClearValueWithDrawPipeline(
     DeviceBase* device,
     const KeyOfApplyClearColorValueWithDrawPipelines& key) {
     InternalPipelineStore* store = device->GetInternalPipelineStore();
     RenderPipelineBase* cachedPipeline = GetCachedPipeline(store, key);
     if (cachedPipeline != nullptr) {
         return cachedPipeline;
     }

     // Prepare the vertex stage
     Ref<ShaderModuleBase> vertexModule;
     DAWN_TRY_ASSIGN(vertexModule, utils::CreateShaderModule(device, kVSSource));
     VertexState vertex = {};
     vertex.module = vertexModule.Get();
     vertex.entryPoint = "main";

     // Prepare the fragment stage
     std::string fragmentShader = ConstructFragmentShader(device, key);
     Ref<ShaderModuleBase> fragmentModule;
     DAWN_TRY_ASSIGN(fragmentModule, utils::CreateShaderModule(device, fragmentShader.c_str()));
     FragmentState fragment = {};
     fragment.module = fragmentModule.Get();
     fragment.entryPoint = "main";

     // Prepare the color states
     PerColorAttachment<ColorTargetState> colorTargets = {};
     for (auto [i, target] : Enumerate(colorTargets)) {
         target.format = key.colorTargetFormats[i];
         // We shouldn't change the color targets that are not involved in.
         if (!key.colorTargetsToApplyClearColorValue[i]) {
             target.writeMask = wgpu::ColorWriteMask::None;
         }
     }

     // Create RenderPipeline
     RenderPipelineDescriptor renderPipelineDesc = {};

     renderPipelineDesc.vertex = vertex;
     renderPipelineDesc.fragment = &fragment;
     renderPipelineDesc.primitive.topology = wgpu::PrimitiveTopology::TriangleList;
     fragment.targetCount = key.colorAttachmentCount;
     fragment.targets = colorTargets.data();

     Ref<RenderPipelineBase> pipeline;
     DAWN_TRY_ASSIGN(pipeline, device->CreateRenderPipeline(&renderPipelineDesc));
     store->applyClearColorValueWithDrawPipelines.insert({key, std::move(pipeline)});

     return GetCachedPipeline(store, key);
 }

 Color GetClearColorValue(const RenderPassColorAttachment& attachment) {
     return attachment.clearValue;
 }

 ResultOrError<Ref<BufferBase>> CreateUniformBufferWithClearValues(
     DeviceBase* device,
     const RenderPassDescriptor* renderPassDescriptor,
     const KeyOfApplyClearColorValueWithDrawPipelines& key) {
     auto colorAttachments = ityp::SpanFromUntyped<ColorAttachmentIndex>(
         renderPassDescriptor->colorAttachments, renderPassDescriptor->colorAttachmentCount);

     std::array<uint8_t, sizeof(uint32_t) * 4 * kMaxColorAttachments> clearValues = {};
     uint32_t offset = 0;
     for (auto i : IterateBitSet(key.colorTargetsToApplyClearColorValue)) {
         const Format& format = colorAttachments[i].view->GetFormat();
         TextureComponentType baseType = format.GetAspectInfo(Aspect::Color).baseType;

         Color initialClearValue = GetClearColorValue(colorAttachments[i]);
         Color clearValue = ClampClearColorValueToLegalRange(initialClearValue, format);
         switch (baseType) {
             case TextureComponentType::Uint: {
                 uint32_t* clearValuePtr = reinterpret_cast<uint32_t*>(clearValues.data() + offset);
                 clearValuePtr[0] = static_cast<uint32_t>(clearValue.r);
                 clearValuePtr[1] = static_cast<uint32_t>(clearValue.g);
                 clearValuePtr[2] = static_cast<uint32_t>(clearValue.b);
                 clearValuePtr[3] = static_cast<uint32_t>(clearValue.a);
                 break;
             }
             case TextureComponentType::Sint: {
                 int32_t* clearValuePtr = reinterpret_cast<int32_t*>(clearValues.data() + offset);
                 clearValuePtr[0] = static_cast<int32_t>(clearValue.r);
                 clearValuePtr[1] = static_cast<int32_t>(clearValue.g);
                 clearValuePtr[2] = static_cast<int32_t>(clearValue.b);
                 clearValuePtr[3] = static_cast<int32_t>(clearValue.a);
                 break;
             }
             case TextureComponentType::Float: {
                 float* clearValuePtr = reinterpret_cast<float*>(clearValues.data() + offset);
                 clearValuePtr[0] = static_cast<float>(clearValue.r);
                 clearValuePtr[1] = static_cast<float>(clearValue.g);
                 clearValuePtr[2] = static_cast<float>(clearValue.b);
                 clearValuePtr[3] = static_cast<float>(clearValue.a);
                 break;
             }
         }
         offset += sizeof(uint32_t) * 4;
     }

     DAWN_ASSERT(offset > 0);

     Ref<BufferBase> outputBuffer;
     DAWN_TRY_ASSIGN(
         outputBuffer,
         utils::CreateBufferFromData(device, wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Uniform,
                                     clearValues.data(), offset));

     return std::move(outputBuffer);
 }

 // Helper functions for applying big integer clear values with draw
 bool ShouldApplyClearBigIntegerColorValueWithDraw(
     const RenderPassColorAttachment& colorAttachmentInfo) {
     if (colorAttachmentInfo.view == nullptr) {
         return false;
     }

     if (colorAttachmentInfo.loadOp != wgpu::LoadOp::Clear) {
         return false;
     }

     // We should only apply this workaround on 32-bit signed and unsigned integer formats.
     const Format& format = colorAttachmentInfo.view->GetFormat();
     switch (format.format) {
         case wgpu::TextureFormat::R32Sint:
         case wgpu::TextureFormat::RG32Sint:
         case wgpu::TextureFormat::RGBA32Sint:
         case wgpu::TextureFormat::R32Uint:
         case wgpu::TextureFormat::RG32Uint:
         case wgpu::TextureFormat::RGBA32Uint:
             break;
         default:
             return false;
     }

     // TODO(dawn:537): only check the color channels that are available in the current color format.
     Color clearValue = GetClearColorValue(colorAttachmentInfo);
     switch (format.GetAspectInfo(Aspect::Color).baseType) {
         case TextureComponentType::Uint: {
             constexpr double kMaxUintRepresentableInFloat = 1 << std::numeric_limits<float>::digits;
             if (clearValue.r <= kMaxUintRepresentableInFloat &&
                 clearValue.g <= kMaxUintRepresentableInFloat &&
                 clearValue.b <= kMaxUintRepresentableInFloat &&
                 clearValue.a <= kMaxUintRepresentableInFloat) {
                 return false;
             }
             break;
         }
         case TextureComponentType::Sint: {
             constexpr double kMaxSintRepresentableInFloat = 1 << std::numeric_limits<float>::digits;
             constexpr double kMinSintRepresentableInFloat = -kMaxSintRepresentableInFloat;
             if (clearValue.r <= kMaxSintRepresentableInFloat &&
                 clearValue.r >= kMinSintRepresentableInFloat &&
                 clearValue.g <= kMaxSintRepresentableInFloat &&
                 clearValue.g >= kMinSintRepresentableInFloat &&
                 clearValue.b <= kMaxSintRepresentableInFloat &&
                 clearValue.b >= kMinSintRepresentableInFloat &&
                 clearValue.a <= kMaxSintRepresentableInFloat &&
                 clearValue.a >= kMinSintRepresentableInFloat) {
                 return false;
             }
             break;
         }
         case TextureComponentType::Float:
             DAWN_UNREACHABLE();
             return false;
     }

     return true;
 }

 KeyOfApplyClearColorValueWithDrawPipelines GetKeyOfApplyClearColorValueWithDrawPipelines(
     const RenderPassDescriptor* renderPassDescriptor) {
     KeyOfApplyClearColorValueWithDrawPipelines key;
     key.colorAttachmentCount = renderPassDescriptor->colorAttachmentCount;

     auto colorAttachments = ityp::SpanFromUntyped<ColorAttachmentIndex>(
         renderPassDescriptor->colorAttachments, renderPassDescriptor->colorAttachmentCount);

     key.colorTargetFormats.fill(wgpu::TextureFormat::Undefined);
     for (auto [i, attachment] : Enumerate(colorAttachments)) {
         if (attachment.view != nullptr) {
             key.colorTargetFormats[i] = attachment.view->GetFormat().format;
         }

         if (ShouldApplyClearBigIntegerColorValueWithDraw(attachment)) {
             key.colorTargetsToApplyClearColorValue.set(i);
         }
     }
     return key;
 }

 }  // namespace

 size_t KeyOfApplyClearColorValueWithDrawPipelinesHashFunc::operator()(
     KeyOfApplyClearColorValueWithDrawPipelines key) const {
     size_t hash = 0;

     HashCombine(&hash, key.colorAttachmentCount);

     HashCombine(&hash, key.colorTargetsToApplyClearColorValue);

     for (wgpu::TextureFormat format : key.colorTargetFormats) {
         HashCombine(&hash, format);
     }

     return hash;
 }

 bool KeyOfApplyClearColorValueWithDrawPipelinesEqualityFunc::operator()(
     KeyOfApplyClearColorValueWithDrawPipelines key1,
     KeyOfApplyClearColorValueWithDrawPipelines key2) const {
     if (key1.colorAttachmentCount != key2.colorAttachmentCount) {
         return false;
     }

     if (key1.colorTargetsToApplyClearColorValue != key2.colorTargetsToApplyClearColorValue) {
         return false;
     }

     for (auto i : Range(key1.colorTargetFormats.size())) {
         if (key1.colorTargetFormats[i] != key2.colorTargetFormats[i]) {
             return false;
         }
     }
     return true;
 }

 bool ShouldApplyClearBigIntegerColorValueWithDraw(
     const DeviceBase* device,
     const RenderPassDescriptor* renderPassDescriptor) {
     if (!device->IsToggleEnabled(Toggle::ApplyClearBigIntegerColorValueWithDraw)) {
         return false;
     }

     for (uint32_t i = 0; i < renderPassDescriptor->colorAttachmentCount; ++i) {
         if (ShouldApplyClearBigIntegerColorValueWithDraw(
                 renderPassDescriptor->colorAttachments[i])) {
             return true;
         }
     }

     return false;
 }

 MaybeError ApplyClearBigIntegerColorValueWithDraw(
     RenderPassEncoder* renderPassEncoder,
     const RenderPassDescriptor* renderPassDescriptor) {
     DeviceBase* device = renderPassEncoder->GetDevice();

     KeyOfApplyClearColorValueWithDrawPipelines key =
         GetKeyOfApplyClearColorValueWithDrawPipelines(renderPassDescriptor);

     RenderPipelineBase* pipeline = nullptr;
     DAWN_TRY_ASSIGN(pipeline, GetOrCreateApplyClearValueWithDrawPipeline(device, key));

     Ref<BindGroupLayoutBase> layout;
     DAWN_TRY_ASSIGN(layout, pipeline->GetBindGroupLayout(0));

     Ref<BufferBase> uniformBufferWithClearColorValues;
     DAWN_TRY_ASSIGN(uniformBufferWithClearColorValues,
                     CreateUniformBufferWithClearValues(device, renderPassDescriptor, key));

     Ref<BindGroupBase> bindGroup;
     DAWN_TRY_ASSIGN(bindGroup,
                     utils::MakeBindGroup(device, layout, {{0, uniformBufferWithClearColorValues}},
                                          UsageValidationMode::Internal));

     renderPassEncoder->APISetBindGroup(0, bindGroup.Get());
     renderPassEncoder->APISetPipeline(pipeline);
     renderPassEncoder->APIDraw(6);

     return {};
 }

 }  // namespace dawn::native
	// Copyright 2022 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/native/ApplyClearColorValueWithDrawHelper.h"

	#include <limits>
	#include <string>
	#include <utility>
	#include <vector>

	#include "dawn/common/Enumerator.h"
	#include "dawn/common/Range.h"
	#include "dawn/native/BindGroup.h"
	#include "dawn/native/BindGroupLayout.h"
	#include "dawn/native/Device.h"
	#include "dawn/native/InternalPipelineStore.h"
	#include "dawn/native/ObjectContentHasher.h"
	#include "dawn/native/RenderPassEncoder.h"
	#include "dawn/native/RenderPipeline.h"
	#include "dawn/native/utils/WGPUHelpers.h"
	#include "dawn/native/webgpu_absl_format.h"

	namespace dawn::native {

	namespace {

	// General helper functions and data structures for applying clear values with draw
	static const char kVSSource[] = R"(
	@vertex
	fn main(@builtin(vertex_index) VertexIndex : u32) -> @builtin(position) vec4f {
	var pos = array(
	vec2f( 0.0, -1.0),
	vec2f( 1.0, -1.0),
	vec2f( 0.0, 1.0),
	vec2f( 0.0, 1.0),
	vec2f( 1.0, -1.0),
	vec2f( 1.0, 1.0));
	return vec4f(pos[VertexIndex], 0.0, 1.0);
	})";

	const char* GetTextureComponentTypeString(DeviceBase* device, wgpu::TextureFormat format) {
	DAWN_ASSERT(format != wgpu::TextureFormat::Undefined);

	const Format& formatInfo = device->GetValidInternalFormat(format);
	switch (formatInfo.GetAspectInfo(Aspect::Color).baseType) {
	case TextureComponentType::Sint:
	return "i32";
	case TextureComponentType::Uint:
	return "u32";
	case TextureComponentType::Float:
	break;
	}
	DAWN_UNREACHABLE();
	}

	// Construct the fragment shader to apply the input color values to the corresponding color
	// attachments of KeyOfApplyClearColorValueWithDrawPipelines.
	std::string ConstructFragmentShader(DeviceBase* device,
	const KeyOfApplyClearColorValueWithDrawPipelines& key) {
	std::ostringstream outputColorDeclarationStream;
	std::ostringstream clearValueUniformBufferDeclarationStream;
	std::ostringstream assignOutputColorStream;

	outputColorDeclarationStream << "struct OutputColor {" << std::endl;
	clearValueUniformBufferDeclarationStream << "struct ClearColors {" << std::endl;

	// Only generate the assignments we need.
	for (auto i : IterateBitSet(key.colorTargetsToApplyClearColorValue)) {
	wgpu::TextureFormat currentFormat = key.colorTargetFormats[i];
	DAWN_ASSERT(currentFormat != wgpu::TextureFormat::Undefined);

	const char* type = GetTextureComponentTypeString(device, currentFormat);

	outputColorDeclarationStream
	<< absl::StrFormat("@location(%u) output%u : vec4<%s>,\n", i, i, type);
	clearValueUniformBufferDeclarationStream
	<< absl::StrFormat("color%u : vec4<%s>,\n", i, type);
	assignOutputColorStream << absl::StrFormat("outputColor.output%u = clearColors.color%u;\n",
	i, i);
	}
	outputColorDeclarationStream << "}" << std::endl;
	clearValueUniformBufferDeclarationStream << "}" << std::endl;

	std::ostringstream fragmentShaderStream;
	fragmentShaderStream << outputColorDeclarationStream.str()
	<< clearValueUniformBufferDeclarationStream.str() << R"(
	@group(0) @binding(0) var<uniform> clearColors : ClearColors;

	@fragment
	fn main() -> OutputColor {
	var outputColor : OutputColor;
	)" << assignOutputColorStream.str()
	<< R"(
	return outputColor;
	})";

	return fragmentShaderStream.str();
	}

	RenderPipelineBase* GetCachedPipeline(InternalPipelineStore* store,
	const KeyOfApplyClearColorValueWithDrawPipelines& key) {
	auto iter = store->applyClearColorValueWithDrawPipelines.find(key);
	if (iter != store->applyClearColorValueWithDrawPipelines.end()) {
	return iter->second.Get();
	}
	return nullptr;
	}

	ResultOrError<RenderPipelineBase*> GetOrCreateApplyClearValueWithDrawPipeline(
	DeviceBase* device,
	const KeyOfApplyClearColorValueWithDrawPipelines& key) {
	InternalPipelineStore* store = device->GetInternalPipelineStore();
	RenderPipelineBase* cachedPipeline = GetCachedPipeline(store, key);
	if (cachedPipeline != nullptr) {
	return cachedPipeline;
	}

	// Prepare the vertex stage
	Ref<ShaderModuleBase> vertexModule;
	DAWN_TRY_ASSIGN(vertexModule, utils::CreateShaderModule(device, kVSSource));
	VertexState vertex = {};
	vertex.module = vertexModule.Get();
	vertex.entryPoint = "main";

	// Prepare the fragment stage
	std::string fragmentShader = ConstructFragmentShader(device, key);
	Ref<ShaderModuleBase> fragmentModule;
	DAWN_TRY_ASSIGN(fragmentModule, utils::CreateShaderModule(device, fragmentShader.c_str()));
	FragmentState fragment = {};
	fragment.module = fragmentModule.Get();
	fragment.entryPoint = "main";

	// Prepare the color states
	PerColorAttachment<ColorTargetState> colorTargets = {};
	for (auto [i, target] : Enumerate(colorTargets)) {
	target.format = key.colorTargetFormats[i];
	// We shouldn't change the color targets that are not involved in.
	if (!key.colorTargetsToApplyClearColorValue[i]) {
	target.writeMask = wgpu::ColorWriteMask::None;
	}
	}

	// Create RenderPipeline
	RenderPipelineDescriptor renderPipelineDesc = {};

	renderPipelineDesc.vertex = vertex;
	renderPipelineDesc.fragment = &fragment;
	renderPipelineDesc.primitive.topology = wgpu::PrimitiveTopology::TriangleList;
	fragment.targetCount = key.colorAttachmentCount;
	fragment.targets = colorTargets.data();

	Ref<RenderPipelineBase> pipeline;
	DAWN_TRY_ASSIGN(pipeline, device->CreateRenderPipeline(&renderPipelineDesc));
	store->applyClearColorValueWithDrawPipelines.insert({key, std::move(pipeline)});

	return GetCachedPipeline(store, key);
	}

	Color GetClearColorValue(const RenderPassColorAttachment& attachment) {
	return attachment.clearValue;
	}

	ResultOrError<Ref<BufferBase>> CreateUniformBufferWithClearValues(
	DeviceBase* device,
	const RenderPassDescriptor* renderPassDescriptor,
	const KeyOfApplyClearColorValueWithDrawPipelines& key) {
	auto colorAttachments = ityp::SpanFromUntyped<ColorAttachmentIndex>(
	renderPassDescriptor->colorAttachments, renderPassDescriptor->colorAttachmentCount);

	std::array<uint8_t, sizeof(uint32_t) * 4 * kMaxColorAttachments> clearValues = {};
	uint32_t offset = 0;
	for (auto i : IterateBitSet(key.colorTargetsToApplyClearColorValue)) {
	const Format& format = colorAttachments[i].view->GetFormat();
	TextureComponentType baseType = format.GetAspectInfo(Aspect::Color).baseType;

	Color initialClearValue = GetClearColorValue(colorAttachments[i]);
	Color clearValue = ClampClearColorValueToLegalRange(initialClearValue, format);
	switch (baseType) {
	case TextureComponentType::Uint: {
	uint32_t* clearValuePtr = reinterpret_cast<uint32_t*>(clearValues.data() + offset);
	clearValuePtr[0] = static_cast<uint32_t>(clearValue.r);
	clearValuePtr[1] = static_cast<uint32_t>(clearValue.g);
	clearValuePtr[2] = static_cast<uint32_t>(clearValue.b);
	clearValuePtr[3] = static_cast<uint32_t>(clearValue.a);
	break;
	}
	case TextureComponentType::Sint: {
	int32_t* clearValuePtr = reinterpret_cast<int32_t*>(clearValues.data() + offset);
	clearValuePtr[0] = static_cast<int32_t>(clearValue.r);
	clearValuePtr[1] = static_cast<int32_t>(clearValue.g);
	clearValuePtr[2] = static_cast<int32_t>(clearValue.b);
	clearValuePtr[3] = static_cast<int32_t>(clearValue.a);
	break;
	}
	case TextureComponentType::Float: {
	float* clearValuePtr = reinterpret_cast<float*>(clearValues.data() + offset);
	clearValuePtr[0] = static_cast<float>(clearValue.r);
	clearValuePtr[1] = static_cast<float>(clearValue.g);
	clearValuePtr[2] = static_cast<float>(clearValue.b);
	clearValuePtr[3] = static_cast<float>(clearValue.a);
	break;
	}
	}
	offset += sizeof(uint32_t) * 4;
	}

	DAWN_ASSERT(offset > 0);

	Ref<BufferBase> outputBuffer;
	DAWN_TRY_ASSIGN(
	outputBuffer,
	utils::CreateBufferFromData(device, wgpu::BufferUsage::CopyDst \| wgpu::BufferUsage::Uniform,
	clearValues.data(), offset));

	return std::move(outputBuffer);
	}

	// Helper functions for applying big integer clear values with draw
	bool ShouldApplyClearBigIntegerColorValueWithDraw(
	const RenderPassColorAttachment& colorAttachmentInfo) {
	if (colorAttachmentInfo.view == nullptr) {
	return false;
	}

	if (colorAttachmentInfo.loadOp != wgpu::LoadOp::Clear) {
	return false;
	}

	// We should only apply this workaround on 32-bit signed and unsigned integer formats.
	const Format& format = colorAttachmentInfo.view->GetFormat();
	switch (format.format) {
	case wgpu::TextureFormat::R32Sint:
	case wgpu::TextureFormat::RG32Sint:
	case wgpu::TextureFormat::RGBA32Sint:
	case wgpu::TextureFormat::R32Uint:
	case wgpu::TextureFormat::RG32Uint:
	case wgpu::TextureFormat::RGBA32Uint:
	break;
	default:
	return false;
	}

	// TODO(dawn:537): only check the color channels that are available in the current color format.
	Color clearValue = GetClearColorValue(colorAttachmentInfo);
	switch (format.GetAspectInfo(Aspect::Color).baseType) {
	case TextureComponentType::Uint: {
	constexpr double kMaxUintRepresentableInFloat = 1 << std::numeric_limits<float>::digits;
	if (clearValue.r <= kMaxUintRepresentableInFloat &&
	clearValue.g <= kMaxUintRepresentableInFloat &&
	clearValue.b <= kMaxUintRepresentableInFloat &&
	clearValue.a <= kMaxUintRepresentableInFloat) {
	return false;
	}
	break;
	}
	case TextureComponentType::Sint: {
	constexpr double kMaxSintRepresentableInFloat = 1 << std::numeric_limits<float>::digits;
	constexpr double kMinSintRepresentableInFloat = -kMaxSintRepresentableInFloat;
	if (clearValue.r <= kMaxSintRepresentableInFloat &&
	clearValue.r >= kMinSintRepresentableInFloat &&
	clearValue.g <= kMaxSintRepresentableInFloat &&
	clearValue.g >= kMinSintRepresentableInFloat &&
	clearValue.b <= kMaxSintRepresentableInFloat &&
	clearValue.b >= kMinSintRepresentableInFloat &&
	clearValue.a <= kMaxSintRepresentableInFloat &&
	clearValue.a >= kMinSintRepresentableInFloat) {
	return false;
	}
	break;
	}
	case TextureComponentType::Float:
	DAWN_UNREACHABLE();
	return false;
	}

	return true;
	}

	KeyOfApplyClearColorValueWithDrawPipelines GetKeyOfApplyClearColorValueWithDrawPipelines(
	const RenderPassDescriptor* renderPassDescriptor) {
	KeyOfApplyClearColorValueWithDrawPipelines key;
	key.colorAttachmentCount = renderPassDescriptor->colorAttachmentCount;

	auto colorAttachments = ityp::SpanFromUntyped<ColorAttachmentIndex>(
	renderPassDescriptor->colorAttachments, renderPassDescriptor->colorAttachmentCount);

	key.colorTargetFormats.fill(wgpu::TextureFormat::Undefined);
	for (auto [i, attachment] : Enumerate(colorAttachments)) {
	if (attachment.view != nullptr) {
	key.colorTargetFormats[i] = attachment.view->GetFormat().format;
	}

	if (ShouldApplyClearBigIntegerColorValueWithDraw(attachment)) {
	key.colorTargetsToApplyClearColorValue.set(i);
	}
	}
	return key;
	}

	} // namespace

	size_t KeyOfApplyClearColorValueWithDrawPipelinesHashFunc::operator()(
	KeyOfApplyClearColorValueWithDrawPipelines key) const {
	size_t hash = 0;

	HashCombine(&hash, key.colorAttachmentCount);

	HashCombine(&hash, key.colorTargetsToApplyClearColorValue);

	for (wgpu::TextureFormat format : key.colorTargetFormats) {
	HashCombine(&hash, format);
	}

	return hash;
	}

	bool KeyOfApplyClearColorValueWithDrawPipelinesEqualityFunc::operator()(
	KeyOfApplyClearColorValueWithDrawPipelines key1,
	KeyOfApplyClearColorValueWithDrawPipelines key2) const {
	if (key1.colorAttachmentCount != key2.colorAttachmentCount) {
	return false;
	}

	if (key1.colorTargetsToApplyClearColorValue != key2.colorTargetsToApplyClearColorValue) {
	return false;
	}

	for (auto i : Range(key1.colorTargetFormats.size())) {
	if (key1.colorTargetFormats[i] != key2.colorTargetFormats[i]) {
	return false;
	}
	}
	return true;
	}

	bool ShouldApplyClearBigIntegerColorValueWithDraw(
	const DeviceBase* device,
	const RenderPassDescriptor* renderPassDescriptor) {
	if (!device->IsToggleEnabled(Toggle::ApplyClearBigIntegerColorValueWithDraw)) {
	return false;
	}

	for (uint32_t i = 0; i < renderPassDescriptor->colorAttachmentCount; ++i) {
	if (ShouldApplyClearBigIntegerColorValueWithDraw(
	renderPassDescriptor->colorAttachments[i])) {
	return true;
	}
	}

	return false;
	}

	MaybeError ApplyClearBigIntegerColorValueWithDraw(
	RenderPassEncoder* renderPassEncoder,
	const RenderPassDescriptor* renderPassDescriptor) {
	DeviceBase* device = renderPassEncoder->GetDevice();

	KeyOfApplyClearColorValueWithDrawPipelines key =
	GetKeyOfApplyClearColorValueWithDrawPipelines(renderPassDescriptor);

	RenderPipelineBase* pipeline = nullptr;
	DAWN_TRY_ASSIGN(pipeline, GetOrCreateApplyClearValueWithDrawPipeline(device, key));

	Ref<BindGroupLayoutBase> layout;
	DAWN_TRY_ASSIGN(layout, pipeline->GetBindGroupLayout(0));

	Ref<BufferBase> uniformBufferWithClearColorValues;
	DAWN_TRY_ASSIGN(uniformBufferWithClearColorValues,
	CreateUniformBufferWithClearValues(device, renderPassDescriptor, key));

	Ref<BindGroupBase> bindGroup;
	DAWN_TRY_ASSIGN(bindGroup,
	utils::MakeBindGroup(device, layout, {{0, uniformBufferWithClearColorValues}},
	UsageValidationMode::Internal));

	renderPassEncoder->APISetBindGroup(0, bindGroup.Get());
	renderPassEncoder->APISetPipeline(pipeline);
	renderPassEncoder->APIDraw(6);

	return {};
	}

	} // namespace dawn::native