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

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

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

 #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"

 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) vec4<f32> {
     var pos = array<vec2<f32>, 6>(
         vec2<f32>( 0.0, -1.0),
         vec2<f32>( 1.0, -1.0),
         vec2<f32>( 0.0,  1.0),
         vec2<f32>( 0.0,  1.0),
         vec2<f32>( 1.0, -1.0),
         vec2<f32>( 1.0,  1.0));
         return vec4<f32>(pos[VertexIndex], 0.0, 1.0);
 })";

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

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

 // 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 (uint32_t i : IterateBitSet(key.colorTargetsToApplyClearColorValue)) {
         wgpu::TextureFormat currentFormat = key.colorTargetFormats[i];
         ASSERT(currentFormat != wgpu::TextureFormat::Undefined);

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

         outputColorDeclarationStream << "@location(" << i << ") output" << i << " : vec4<" << type
                                      << ">," << std::endl;
         clearValueUniformBufferDeclarationStream << "color" << i << " : vec4<" << type << ">,"
                                                  << std::endl;
         assignOutputColorStream << "outputColor.output" << i << " = clearColors.color" << i << ";"
                                 << std::endl;
     }
     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
     std::array<ColorTargetState, kMaxColorAttachments> colorTargets = {};
     for (uint32_t i = 0; i < kMaxColorAttachments; ++i) {
         colorTargets[i].format = key.colorTargetFormats[i];
         // We shouldn't change the color targets that are not involved in.
         if (!key.colorTargetsToApplyClearColorValue[i]) {
             colorTargets[i].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 HasDeprecatedColor(attachment) ? attachment.clearColor : attachment.clearValue;
 }

 ResultOrError<Ref<BufferBase>> CreateUniformBufferWithClearValues(
     DeviceBase* device,
     const RenderPassDescriptor* renderPassDescriptor,
     const KeyOfApplyClearColorValueWithDrawPipelines& key) {
     std::array<uint8_t, sizeof(uint32_t)* 4 * kMaxColorAttachments> clearValues = {};
     uint32_t offset = 0;
     for (uint32_t i : IterateBitSet(key.colorTargetsToApplyClearColorValue)) {
         const Format& format = renderPassDescriptor->colorAttachments[i].view->GetFormat();
         wgpu::TextureComponentType baseType = format.GetAspectInfo(Aspect::Color).baseType;

         Color initialClearValue = GetClearColorValue(renderPassDescriptor->colorAttachments[i]);
         Color clearValue = ClampClearColorValueToLegalRange(initialClearValue, format);
         switch (baseType) {
             case wgpu::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 wgpu::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 wgpu::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;
             }

             case wgpu::TextureComponentType::DepthComparison:
             default:
                 UNREACHABLE();
                 break;
         }
         offset += sizeof(uint32_t) * 4;
     }

     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 wgpu::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 wgpu::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 wgpu::TextureComponentType::Float:
         case wgpu::TextureComponentType::DepthComparison:
         default:
             UNREACHABLE();
             return false;
     }

     return true;
 }

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

     key.colorTargetFormats.fill(wgpu::TextureFormat::Undefined);
     for (uint32_t i = 0; i < renderPassDescriptor->colorAttachmentCount; ++i) {
         if (renderPassDescriptor->colorAttachments[i].view != nullptr) {
             key.colorTargetFormats[i] =
                 renderPassDescriptor->colorAttachments[i].view->GetFormat().format;
         }

         if (ShouldApplyClearBigIntegerColorValueWithDraw(
                 renderPassDescriptor->colorAttachments[i])) {
             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 (uint32_t i = 0; i < kMaxColorAttachments; ++i) {
         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 Authors
	//
	// 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 "dawn/native/ApplyClearColorValueWithDrawHelper.h"

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

	#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"

	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) vec4<f32> {
	var pos = array<vec2<f32>, 6>(
	vec2<f32>( 0.0, -1.0),
	vec2<f32>( 1.0, -1.0),
	vec2<f32>( 0.0, 1.0),
	vec2<f32>( 0.0, 1.0),
	vec2<f32>( 1.0, -1.0),
	vec2<f32>( 1.0, 1.0));
	return vec4<f32>(pos[VertexIndex], 0.0, 1.0);
	})";

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

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

	// 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 (uint32_t i : IterateBitSet(key.colorTargetsToApplyClearColorValue)) {
	wgpu::TextureFormat currentFormat = key.colorTargetFormats[i];
	ASSERT(currentFormat != wgpu::TextureFormat::Undefined);

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

	outputColorDeclarationStream << "@location(" << i << ") output" << i << " : vec4<" << type
	<< ">," << std::endl;
	clearValueUniformBufferDeclarationStream << "color" << i << " : vec4<" << type << ">,"
	<< std::endl;
	assignOutputColorStream << "outputColor.output" << i << " = clearColors.color" << i << ";"
	<< std::endl;
	}
	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
	std::array<ColorTargetState, kMaxColorAttachments> colorTargets = {};
	for (uint32_t i = 0; i < kMaxColorAttachments; ++i) {
	colorTargets[i].format = key.colorTargetFormats[i];
	// We shouldn't change the color targets that are not involved in.
	if (!key.colorTargetsToApplyClearColorValue[i]) {
	colorTargets[i].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 HasDeprecatedColor(attachment) ? attachment.clearColor : attachment.clearValue;
	}

	ResultOrError<Ref<BufferBase>> CreateUniformBufferWithClearValues(
	DeviceBase* device,
	const RenderPassDescriptor* renderPassDescriptor,
	const KeyOfApplyClearColorValueWithDrawPipelines& key) {
	std::array<uint8_t, sizeof(uint32_t)* 4 * kMaxColorAttachments> clearValues = {};
	uint32_t offset = 0;
	for (uint32_t i : IterateBitSet(key.colorTargetsToApplyClearColorValue)) {
	const Format& format = renderPassDescriptor->colorAttachments[i].view->GetFormat();
	wgpu::TextureComponentType baseType = format.GetAspectInfo(Aspect::Color).baseType;

	Color initialClearValue = GetClearColorValue(renderPassDescriptor->colorAttachments[i]);
	Color clearValue = ClampClearColorValueToLegalRange(initialClearValue, format);
	switch (baseType) {
	case wgpu::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 wgpu::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 wgpu::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;
	}

	case wgpu::TextureComponentType::DepthComparison:
	default:
	UNREACHABLE();
	break;
	}
	offset += sizeof(uint32_t) * 4;
	}

	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 wgpu::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 wgpu::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 wgpu::TextureComponentType::Float:
	case wgpu::TextureComponentType::DepthComparison:
	default:
	UNREACHABLE();
	return false;
	}

	return true;
	}

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

	key.colorTargetFormats.fill(wgpu::TextureFormat::Undefined);
	for (uint32_t i = 0; i < renderPassDescriptor->colorAttachmentCount; ++i) {
	if (renderPassDescriptor->colorAttachments[i].view != nullptr) {
	key.colorTargetFormats[i] =
	renderPassDescriptor->colorAttachments[i].view->GetFormat().format;
	}

	if (ShouldApplyClearBigIntegerColorValueWithDraw(
	renderPassDescriptor->colorAttachments[i])) {
	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 (uint32_t i = 0; i < kMaxColorAttachments; ++i) {
	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