| // Copyright 2019 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "third_party/blink/renderer/modules/webgpu/dawn_conversions.h" |
| |
| #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_color_dict.h" |
| #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_extent_3d_dict.h" |
| #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_index_format.h" |
| #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_origin_2d_dict.h" |
| #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_origin_3d_dict.h" |
| #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_programmable_stage.h" |
| #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_texel_copy_buffer_layout.h" |
| #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_texel_copy_texture_info.h" |
| #include "third_party/blink/renderer/bindings/modules/v8/v8_union_doublesequence_gpucolordict.h" |
| #include "third_party/blink/renderer/bindings/modules/v8/v8_union_gpuautolayoutmode_gpupipelinelayout.h" |
| #include "third_party/blink/renderer/bindings/modules/v8/v8_union_gpuextent3ddict_unsignedlongenforcerangesequence.h" |
| #include "third_party/blink/renderer/bindings/modules/v8/v8_union_gpuorigin2ddict_unsignedlongenforcerangesequence.h" |
| #include "third_party/blink/renderer/bindings/modules/v8/v8_union_gpuorigin3ddict_unsignedlongenforcerangesequence.h" |
| #include "third_party/blink/renderer/modules/webgpu/gpu_device.h" |
| #include "third_party/blink/renderer/modules/webgpu/gpu_pipeline_layout.h" |
| #include "third_party/blink/renderer/modules/webgpu/gpu_shader_module.h" |
| #include "third_party/blink/renderer/modules/webgpu/gpu_texture.h" |
| #include "third_party/blink/renderer/platform/bindings/exception_state.h" |
| |
| namespace blink { |
| |
| bool ConvertToDawn(const V8GPUColor* in, |
| wgpu::Color* out, |
| ExceptionState& exception_state) { |
| switch (in->GetContentType()) { |
| case V8GPUColor::ContentType::kGPUColorDict: { |
| const GPUColorDict* dict = in->GetAsGPUColorDict(); |
| *out = {dict->r(), dict->g(), dict->b(), dict->a()}; |
| return true; |
| } |
| |
| case V8GPUColor::ContentType::kDoubleSequence: { |
| const Vector<double>& sequence = in->GetAsDoubleSequence(); |
| if (sequence.size() != 4) { |
| exception_state.ThrowTypeError( |
| "A sequence of number used as a GPUColor must have exactly 4 " |
| "elements."); |
| return false; |
| } |
| *out = {sequence[0], sequence[1], sequence[2], sequence[3]}; |
| return true; |
| } |
| } |
| } |
| |
| bool ConvertToDawn(const V8GPUExtent3D* in, |
| wgpu::Extent3D* out, |
| GPUDevice* device, |
| ExceptionState& exception_state) { |
| switch (in->GetContentType()) { |
| case V8GPUExtent3D::ContentType::kGPUExtent3DDict: { |
| const GPUExtent3DDict* dict = in->GetAsGPUExtent3DDict(); |
| *out = {dict->width(), dict->height(), dict->depthOrArrayLayers()}; |
| if (dict->hasDepth()) { |
| device->AddSingletonWarning(GPUSingletonWarning::kDepthKey); |
| } |
| return true; |
| } |
| |
| case V8GPUExtent3D::ContentType::kUnsignedLongEnforceRangeSequence: { |
| const Vector<uint32_t>& sequence = |
| in->GetAsUnsignedLongEnforceRangeSequence(); |
| // The WebGPU spec states that height and depthOrArrayLayers default to 1 |
| // when the sequence isn't big enough. |
| switch (sequence.size()) { |
| case 1: |
| *out = {sequence[0], 1, 1}; |
| return true; |
| case 2: |
| *out = {sequence[0], sequence[1], 1}; |
| return true; |
| case 3: |
| *out = {sequence[0], sequence[1], sequence[2]}; |
| return true; |
| default: |
| exception_state.ThrowTypeError( |
| "A sequence of number used as a GPUExtent3D must have between 1 " |
| "and 3 elements."); |
| return false; |
| } |
| } |
| } |
| } |
| |
| bool ConvertToDawn(const V8GPUOrigin3D* in, |
| wgpu::Origin3D* out, |
| ExceptionState& exception_state) { |
| switch (in->GetContentType()) { |
| case V8GPUOrigin3D::ContentType::kGPUOrigin3DDict: { |
| const GPUOrigin3DDict* dict = in->GetAsGPUOrigin3DDict(); |
| *out = {dict->x(), dict->y(), dict->z()}; |
| return true; |
| } |
| |
| case V8GPUOrigin3D::ContentType::kUnsignedLongEnforceRangeSequence: { |
| const Vector<uint32_t>& sequence = |
| in->GetAsUnsignedLongEnforceRangeSequence(); |
| // The WebGPU spec states that coordinates default to 0 when the sequence |
| // isn't big enough. |
| switch (sequence.size()) { |
| case 0: |
| *out = {0, 0, 0}; |
| return true; |
| case 1: |
| *out = {sequence[0], 0, 0}; |
| return true; |
| case 2: |
| *out = {sequence[0], sequence[1], 0}; |
| return true; |
| case 3: |
| *out = {sequence[0], sequence[1], sequence[2]}; |
| return true; |
| default: |
| exception_state.ThrowTypeError( |
| "A sequence of number used as a GPUOrigin3D must have at most 3 " |
| "elements."); |
| return false; |
| } |
| } |
| } |
| } |
| |
| bool ConvertToDawn(const V8GPUOrigin2D* in, |
| wgpu::Origin2D* out, |
| ExceptionState& exception_state) { |
| switch (in->GetContentType()) { |
| case V8GPUOrigin2D::ContentType::kGPUOrigin2DDict: { |
| const GPUOrigin2DDict* dict = in->GetAsGPUOrigin2DDict(); |
| *out = {dict->x(), dict->y()}; |
| return true; |
| } |
| |
| case V8GPUOrigin2D::ContentType::kUnsignedLongEnforceRangeSequence: { |
| const Vector<uint32_t>& sequence = |
| in->GetAsUnsignedLongEnforceRangeSequence(); |
| // The WebGPU spec states that coordinates default to 0 when the sequence |
| // isn't big enough. |
| switch (sequence.size()) { |
| case 0: |
| *out = {0, 0}; |
| return true; |
| case 1: |
| *out = {sequence[0], 0}; |
| return true; |
| case 2: |
| *out = {sequence[0], sequence[1]}; |
| return true; |
| default: |
| exception_state.ThrowTypeError( |
| "A sequence of number used as a GPUOrigin2D must have at most 2 " |
| "elements."); |
| return false; |
| } |
| } |
| } |
| } |
| |
| bool ConvertToDawn(const GPUTexelCopyTextureInfo* in, |
| wgpu::TexelCopyTextureInfo* out, |
| ExceptionState& exception_state) { |
| DCHECK(in); |
| DCHECK(in->texture()); |
| |
| *out = { |
| .texture = in->texture()->GetHandle(), |
| .mipLevel = in->mipLevel(), |
| .aspect = AsDawnEnum(in->aspect()), |
| }; |
| return ConvertToDawn(in->origin(), &out->origin, exception_state); |
| } |
| |
| // Dawn represents `undefined` as the special uint32_t value |
| // wgpu::kCopyStrideUndefined (0xFFFF'FFFF). Blink must make sure that an |
| // actual value of 0xFFFF'FFFF coming in from JS is not treated as |
| // wgpu::kCopyStrideUndefined, so it injects an error in that case. |
| const char* ValidateTexelCopyBufferLayout( |
| const GPUTexelCopyBufferLayout* webgpu_layout, |
| wgpu::TexelCopyBufferLayout* dawn_layout) { |
| DCHECK(webgpu_layout); |
| |
| uint32_t bytesPerRow = 0; |
| if (webgpu_layout->hasBytesPerRow()) { |
| bytesPerRow = webgpu_layout->bytesPerRow(); |
| if (bytesPerRow == wgpu::kCopyStrideUndefined) { |
| return "bytesPerRow must be a multiple of 256"; |
| } |
| } else { |
| bytesPerRow = wgpu::kCopyStrideUndefined; |
| } |
| |
| uint32_t rowsPerImage = 0; |
| if (webgpu_layout->hasRowsPerImage()) { |
| rowsPerImage = webgpu_layout->rowsPerImage(); |
| if (rowsPerImage == wgpu::kCopyStrideUndefined) { |
| return "rowsPerImage is too large"; |
| } |
| } else { |
| rowsPerImage = wgpu::kCopyStrideUndefined; |
| } |
| |
| *dawn_layout = { |
| .offset = webgpu_layout->offset(), |
| .bytesPerRow = bytesPerRow, |
| .rowsPerImage = rowsPerImage, |
| }; |
| return nullptr; |
| } |
| |
| wgpu::PipelineLayout AsDawnType( |
| V8UnionGPUAutoLayoutModeOrGPUPipelineLayout* webgpu_layout) { |
| DCHECK(webgpu_layout); |
| |
| switch (webgpu_layout->GetContentType()) { |
| case V8UnionGPUAutoLayoutModeOrGPUPipelineLayout::ContentType:: |
| kGPUPipelineLayout: |
| return AsDawnType(webgpu_layout->GetAsGPUPipelineLayout()); |
| case V8UnionGPUAutoLayoutModeOrGPUPipelineLayout::ContentType:: |
| kGPUAutoLayoutMode: |
| return nullptr; |
| } |
| |
| NOTREACHED(); |
| } |
| |
| } // namespace blink |
