kc3-lang/angle/src/libANGLE/renderer/wgpu/wgpu_format_utils.h

• Show log

  Commit

• Hash : 3e997419
  Author :
  Date : 2024-06-25T18:41:03
  

  Add format conversions for WebGPU formats.
  
  This CL adds a Format class, as well as a generator script to
  generate methods to map between WebGPU and ANGLE formats.
  
  Fallback mappings are listed but this CL only implements
  support for required webgpu formats.
  
  Bug: angleproject:344814096
  Change-Id: I2588a57353eafc4e87f40df3bbe3f9375e5ed8c6
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5598178
  Reviewed-by: Matthew Denton <mpdenton@chromium.org>
  Commit-Queue: Liza Burakova <liza@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/renderer/wgpu/wgpu_format_utils.h

• //
  // Copyright 2024 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // wgpu_format_utils:
  //   Helper for WebGPU format code.
  
  #ifndef LIBANGLE_RENDERER_WGPU_WGPU_FORMAT_UTILS_H_
  #define LIBANGLE_RENDERER_WGPU_WGPU_FORMAT_UTILS_H_
  
  #include <dawn/webgpu_cpp.h>
  
  #include "libANGLE/formatutils.h"
  #include "libANGLE/renderer/Format.h"
  #include "libANGLE/renderer/copyvertex.h"
  
  namespace rx
  {
  namespace webgpu
  {
  
  struct ImageFormatInitInfo final
  {
      angle::FormatID format;
      InitializeTextureDataFunction initializer;
  };
  
  struct BufferFormatInitInfo final
  {
      angle::FormatID format;
      VertexCopyFunction VertexLoadFunction;
      bool VertexLoadRequiresConversion;
  };
  
  wgpu::TextureFormat GetWgpuTextureFormatFromFormatID(angle::FormatID formatID);
  angle::FormatID GetFormatIDFromWgpuTextureFormat(wgpu::TextureFormat wgpuFormat);
  wgpu::VertexFormat GetWgpuVertexFormatFromFormatID(angle::FormatID formatID);
  angle::FormatID GetFormatIDFromWgpuBufferFormat(wgpu::VertexFormat wgpuFormat);
  
  // Describes a WebGPU format. WebGPU has separate formats for images and vertex buffers, this class
  // describes both.
  class Format final : private angle::NonCopyable
  {
    public:
      Format();
  
      bool valid() const { return mIntendedGLFormat != 0; }
  
      // The intended format is the front-end format. For Textures this usually correponds to a
      // GLenum in the headers. Buffer formats don't always have a corresponding GLenum type.
      // Some Surface formats and unsized types also don't have a corresponding GLenum.
      angle::FormatID getIntendedFormatID() const { return mIntendedFormatID; }
      const angle::Format &getIntendedFormat() const { return angle::Format::Get(mIntendedFormatID); }
  
      // The actual Image format is used to implement the front-end format for Texture/Renderbuffers.
      const angle::Format &getActualImageFormat() const
      {
          return angle::Format::Get(getActualImageFormatID());
      }
  
      LoadImageFunctionInfo getTextureLoadFunction(GLenum type) const
      {
          return mTextureLoadFunctions(type);
      }
  
      wgpu::TextureFormat getActualWgpuTextureFormat() const
      {
          return GetWgpuTextureFormatFromFormatID(mActualImageFormatID);
      }
      wgpu::VertexFormat getActualWgpuVertexFormat() const
      {
          return GetWgpuVertexFormatFromFormatID(mActualBufferFormatID);
      }
  
      angle::FormatID getActualImageFormatID() const { return mActualImageFormatID; }
  
      // The actual Buffer format is used to implement the front-end format for Buffers.  This format
      // is used by vertex buffers as well as texture buffers.
      const angle::Format &getActualBufferFormat() const
      {
          return angle::Format::Get(mActualBufferFormatID);
      }
  
      // |intendedGLFormat| always correponds to a valid GLenum type. For types that don't have a
      // corresponding GLenum we do our best to specify a GLenum that is "close".
      const gl::InternalFormat &getInternalFormatInfo(GLenum type) const
      {
          return gl::GetInternalFormatInfo(mIntendedGLFormat, type);
      }
  
    private:
      // This is an auto-generated method in vk_format_table_autogen.cpp.
      void initialize(const angle::Format &intendedAngleFormat);
  
      // These are used in the format table init.
      void initImageFallback(const ImageFormatInitInfo *info, int numInfo);
  
      void initBufferFallback(const BufferFormatInitInfo *fallbackInfo, int numInfo);
  
      angle::FormatID mIntendedFormatID;
      GLenum mIntendedGLFormat;
      angle::FormatID mActualImageFormatID;
      angle::FormatID mActualBufferFormatID;
  
      InitializeTextureDataFunction mImageInitializerFunction;
      LoadFunctionMap mTextureLoadFunctions;
      VertexCopyFunction mVertexLoadFunction;
  
      bool mVertexLoadRequiresConversion;
      bool mIsRenderable;
  };
  }  // namespace webgpu
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_WGPU_WGPU_FORMAT_UTILS_H_
  

Download