kc3-lang/angle/src/libANGLE/renderer/metal/TextureMtl.h

• Show log

  Commit

• Hash : 239ef680
  Author :
  Date : 2024-11-21T00:00:00
  

  Metal: Support ANGLE_texture_multisample
  
  * Added explicit multisample texture creation support
  
  * Added support for SAMPLE_MASK frontend state
  
  * Adjusted Metal backend caps
  
  Fixed: angleproject:380475003
  Change-Id: I90250e14da52869cb954b5a61d9c670e958a526c
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6048958
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Alexey Knyazev <lexa.knyazev@gmail.com>
  

Download

• src/libANGLE/renderer/metal/TextureMtl.h

• //
  // Copyright 2019 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.
  //
  // TextureMtl.h:
  //    Defines the class interface for TextureMtl, implementing TextureImpl.
  //
  
  #ifndef LIBANGLE_RENDERER_METAL_TEXTUREMTL_H_
  #define LIBANGLE_RENDERER_METAL_TEXTUREMTL_H_
  
  #include <map>
  
  #include "common/PackedEnums.h"
  #include "libANGLE/renderer/TextureImpl.h"
  #include "libANGLE/renderer/metal/RenderTargetMtl.h"
  #include "libANGLE/renderer/metal/SurfaceMtl.h"
  #include "libANGLE/renderer/metal/mtl_command_buffer.h"
  #include "libANGLE/renderer/metal/mtl_context_device.h"
  #include "libANGLE/renderer/metal/mtl_resources.h"
  namespace rx
  {
  
  // structure represents one image definition of a texture created by glTexImage* call.
  struct ImageDefinitionMtl
  {
      mtl::TextureRef image;
      angle::FormatID formatID = angle::FormatID::NONE;
  };
  
  class TextureMtl : public TextureImpl
  {
    public:
      using TextureViewVector           = std::vector<mtl::TextureRef>;
      using LayerLevelTextureViewVector = std::vector<TextureViewVector>;
  
      TextureMtl(const gl::TextureState &state);
      // Texture  view
      TextureMtl(const TextureMtl &mtl, GLenum format);
      ~TextureMtl() override;
      void onDestroy(const gl::Context *context) override;
  
      angle::Result setImage(const gl::Context *context,
                             const gl::ImageIndex &index,
                             GLenum internalFormat,
                             const gl::Extents &size,
                             GLenum format,
                             GLenum type,
                             const gl::PixelUnpackState &unpack,
                             gl::Buffer *unpackBuffer,
                             const uint8_t *pixels) override;
      angle::Result setSubImage(const gl::Context *context,
                                const gl::ImageIndex &index,
                                const gl::Box &area,
                                GLenum format,
                                GLenum type,
                                const gl::PixelUnpackState &unpack,
                                gl::Buffer *unpackBuffer,
                                const uint8_t *pixels) override;
  
      angle::Result setCompressedImage(const gl::Context *context,
                                       const gl::ImageIndex &index,
                                       GLenum internalFormat,
                                       const gl::Extents &size,
                                       const gl::PixelUnpackState &unpack,
                                       size_t imageSize,
                                       const uint8_t *pixels) override;
      angle::Result setCompressedSubImage(const gl::Context *context,
                                          const gl::ImageIndex &index,
                                          const gl::Box &area,
                                          GLenum format,
                                          const gl::PixelUnpackState &unpack,
                                          size_t imageSize,
                                          const uint8_t *pixels) override;
  
      angle::Result copyImage(const gl::Context *context,
                              const gl::ImageIndex &index,
                              const gl::Rectangle &sourceArea,
                              GLenum internalFormat,
                              gl::Framebuffer *source) override;
      angle::Result copySubImage(const gl::Context *context,
                                 const gl::ImageIndex &index,
                                 const gl::Offset &destOffset,
                                 const gl::Rectangle &sourceArea,
                                 gl::Framebuffer *source) override;
  
      angle::Result copyTexture(const gl::Context *context,
                                const gl::ImageIndex &index,
                                GLenum internalFormat,
                                GLenum type,
                                GLint sourceLevel,
                                bool unpackFlipY,
                                bool unpackPremultiplyAlpha,
                                bool unpackUnmultiplyAlpha,
                                const gl::Texture *source) override;
      angle::Result copySubTexture(const gl::Context *context,
                                   const gl::ImageIndex &index,
                                   const gl::Offset &destOffset,
                                   GLint sourceLevel,
                                   const gl::Box &sourceBox,
                                   bool unpackFlipY,
                                   bool unpackPremultiplyAlpha,
                                   bool unpackUnmultiplyAlpha,
                                   const gl::Texture *source) override;
  
      angle::Result copyCompressedTexture(const gl::Context *context,
                                          const gl::Texture *source) override;
  
      angle::Result setStorage(const gl::Context *context,
                               gl::TextureType type,
                               size_t levels,
                               GLenum internalFormat,
                               const gl::Extents &size) override;
  
      angle::Result setStorageExternalMemory(const gl::Context *context,
                                             gl::TextureType type,
                                             size_t levels,
                                             GLenum internalFormat,
                                             const gl::Extents &size,
                                             gl::MemoryObject *memoryObject,
                                             GLuint64 offset,
                                             GLbitfield createFlags,
                                             GLbitfield usageFlags,
                                             const void *imageCreateInfoPNext) override;
  
      angle::Result setStorageMultisample(const gl::Context *context,
                                          gl::TextureType type,
                                          GLsizei samples,
                                          GLint internalFormat,
                                          const gl::Extents &size,
                                          bool fixedSampleLocations) override;
  
      angle::Result setEGLImageTarget(const gl::Context *context,
                                      gl::TextureType type,
                                      egl::Image *image) override;
  
      angle::Result setImageExternal(const gl::Context *context,
                                     gl::TextureType type,
                                     egl::Stream *stream,
                                     const egl::Stream::GLTextureDescription &desc) override;
  
      angle::Result generateMipmap(const gl::Context *context) override;
  
      angle::Result setBaseLevel(const gl::Context *context, GLuint baseLevel) override;
  
      angle::Result bindTexImage(const gl::Context *context, egl::Surface *surface) override;
      angle::Result releaseTexImage(const gl::Context *context) override;
  
      angle::Result getAttachmentRenderTarget(const gl::Context *context,
                                              GLenum binding,
                                              const gl::ImageIndex &imageIndex,
                                              GLsizei samples,
                                              FramebufferAttachmentRenderTarget **rtOut) override;
  
      angle::Result syncState(const gl::Context *context,
                              const gl::Texture::DirtyBits &dirtyBits,
                              gl::Command source) override;
  
      angle::Result initializeContents(const gl::Context *context,
                                       GLenum binding,
                                       const gl::ImageIndex &imageIndex) override;
  
      // The texture's data is initially initialized and stored in an array
      // of images through glTexImage*/glCopyTex* calls. During draw calls, the caller must make sure
      // the actual texture is created by calling this method to transfer the stored images data
      // to the actual texture.
      angle::Result ensureNativeStorageCreated(const gl::Context *context);
  
      angle::Result bindToShader(const gl::Context *context,
                                 mtl::RenderCommandEncoder *cmdEncoder,
                                 gl::ShaderType shaderType,
                                 gl::Sampler *sampler, /** nullable */
                                 int textureSlotIndex,
                                 int samplerSlotIndex);
  
      angle::Result bindToShaderImage(const gl::Context *context,
                                      mtl::RenderCommandEncoder *cmdEncoder,
                                      gl::ShaderType shaderType,
                                      int textureSlotIndex,
                                      int level,
                                      int layer,
                                      GLenum format);
  
      const mtl::Format &getFormat() const { return mFormat; }
  
    private:
      void deallocateNativeStorage(bool keepImages, bool keepSamplerStateAndFormat = false);
      angle::Result createNativeStorage(const gl::Context *context,
                                        gl::TextureType type,
                                        GLuint mips,
                                        GLuint samples,
                                        const gl::Extents &size);
      angle::Result onBaseMaxLevelsChanged(const gl::Context *context);
      angle::Result ensureSamplerStateCreated(const gl::Context *context);
      // Ensure image at given index is created:
      angle::Result ensureImageCreated(const gl::Context *context, const gl::ImageIndex &index);
      // Ensure all image views at all faces/levels are retained.
      void retainImageDefinitions();
      mtl::TextureRef createImageViewFromTextureStorage(GLuint cubeFaceOrZero, GLuint glLevel);
      angle::Result createViewFromBaseToMaxLevel();
      angle::Result ensureLevelViewsWithinBaseMaxCreated();
      angle::Result checkForEmulatedChannels(const gl::Context *context,
                                             const mtl::Format &mtlFormat,
                                             const mtl::TextureRef &texture);
      mtl::TextureRef &getImage(const gl::ImageIndex &imageIndex);
      ImageDefinitionMtl &getImageDefinition(const gl::ImageIndex &imageIndex);
      angle::Result getRenderTarget(ContextMtl *context,
                                    const gl::ImageIndex &imageIndex,
                                    GLsizei implicitSamples,
                                    RenderTargetMtl **renderTargetOut);
      mtl::TextureRef &getImplicitMSTexture(const gl::ImageIndex &imageIndex);
  
      angle::Result setStorageImpl(const gl::Context *context,
                                   gl::TextureType type,
                                   GLuint mips,
                                   GLuint samples,
                                   const mtl::Format &mtlFormat,
                                   const gl::Extents &size);
  
      angle::Result redefineImage(const gl::Context *context,
                                  const gl::ImageIndex &index,
                                  const mtl::Format &mtlFormat,
                                  const gl::Extents &size);
  
      angle::Result setImageImpl(const gl::Context *context,
                                 const gl::ImageIndex &index,
                                 const gl::InternalFormat &dstFormatInfo,
                                 const gl::Extents &size,
                                 GLenum srcFormat,
                                 GLenum srcType,
                                 const gl::PixelUnpackState &unpack,
                                 gl::Buffer *unpackBuffer,
                                 const uint8_t *pixels);
      angle::Result setSubImageImpl(const gl::Context *context,
                                    const gl::ImageIndex &index,
                                    const gl::Box &area,
                                    const gl::InternalFormat &formatInfo,
                                    GLenum type,
                                    const gl::PixelUnpackState &unpack,
                                    gl::Buffer *unpackBuffer,
                                    const uint8_t *pixels);
  
      angle::Result copySubImageImpl(const gl::Context *context,
                                     const gl::ImageIndex &index,
                                     const gl::Offset &destOffset,
                                     const gl::Rectangle &sourceArea,
                                     const gl::InternalFormat &internalFormat,
                                     const FramebufferMtl *source,
                                     const RenderTargetMtl *sourceRtt);
      angle::Result copySubImageWithDraw(const gl::Context *context,
                                         const gl::ImageIndex &index,
                                         const gl::Offset &destOffset,
                                         const gl::Rectangle &sourceArea,
                                         const gl::InternalFormat &internalFormat,
                                         const FramebufferMtl *source,
                                         const RenderTargetMtl *sourceRtt);
      angle::Result copySubImageCPU(const gl::Context *context,
                                    const gl::ImageIndex &index,
                                    const gl::Offset &destOffset,
                                    const gl::Rectangle &sourceArea,
                                    const gl::InternalFormat &internalFormat,
                                    const FramebufferMtl *source,
                                    const RenderTargetMtl *sourceRtt);
  
      angle::Result copySubTextureImpl(const gl::Context *context,
                                       const gl::ImageIndex &index,
                                       const gl::Offset &destOffset,
                                       const gl::InternalFormat &internalFormat,
                                       GLint sourceLevel,
                                       const gl::Box &sourceBox,
                                       bool unpackFlipY,
                                       bool unpackPremultiplyAlpha,
                                       bool unpackUnmultiplyAlpha,
                                       const gl::Texture *source);
  
      angle::Result copySubTextureWithDraw(const gl::Context *context,
                                           const gl::ImageIndex &index,
                                           const gl::Offset &destOffset,
                                           const gl::InternalFormat &internalFormat,
                                           const mtl::MipmapNativeLevel &sourceNativeLevel,
                                           const gl::Box &sourceBox,
                                           const angle::Format &sourceAngleFormat,
                                           bool unpackFlipY,
                                           bool unpackPremultiplyAlpha,
                                           bool unpackUnmultiplyAlpha,
                                           const mtl::TextureRef &sourceTexture);
  
      angle::Result copySubTextureCPU(const gl::Context *context,
                                      const gl::ImageIndex &index,
                                      const gl::Offset &destOffset,
                                      const gl::InternalFormat &internalFormat,
                                      const mtl::MipmapNativeLevel &sourceNativeLevel,
                                      const gl::Box &sourceBox,
                                      const angle::Format &sourceAngleFormat,
                                      bool unpackFlipY,
                                      bool unpackPremultiplyAlpha,
                                      bool unpackUnmultiplyAlpha,
                                      const mtl::TextureRef &sourceTexture);
  
      // Copy data to texture's per array's slice/cube's face. NOTE: This function doesn't upload
      // data to 3D texture's z layer. Metal treats 3D texture's z layer & array texture's slice
      // differently. For array/cube texture, it is only possible to upload to one slice at a time.
      angle::Result setPerSliceSubImage(const gl::Context *context,
                                        int slice,
                                        const MTLRegion &mtlArea,
                                        const gl::InternalFormat &internalFormat,
                                        GLenum type,
                                        const angle::Format &pixelsAngleFormat,
                                        size_t pixelsRowPitch,
                                        size_t pixelsDepthPitch,
                                        gl::Buffer *unpackBuffer,
                                        const uint8_t *pixels,
                                        const mtl::TextureRef &image);
  
      // Convert pixels to suported format before uploading to texture
      angle::Result convertAndSetPerSliceSubImage(const gl::Context *context,
                                                  int slice,
                                                  const MTLRegion &mtlArea,
                                                  const gl::InternalFormat &internalFormat,
                                                  GLenum type,
                                                  const angle::Format &pixelsAngleFormat,
                                                  size_t pixelsRowPitch,
                                                  size_t pixelsDepthPitch,
                                                  gl::Buffer *unpackBuffer,
                                                  const uint8_t *pixels,
                                                  const mtl::TextureRef &image);
  
      angle::Result generateMipmapCPU(const gl::Context *context);
  
      bool needsFormatViewForPixelLocalStorage(const ShPixelLocalStorageOptions &) const;
      bool isImmutableOrPBuffer() const;
  
      mtl::Format mFormat;
      egl::Surface *mBoundSurface = nullptr;
      class NativeTextureWrapper;
      class NativeTextureWrapperWithViewSupport;
      // The real texture used by Metal.
      // For non-immutable texture, this usually contains levels from (GL base level -> GL max level).
      // For immutable texture, this contains levels allocated with glTexStorage which could be
      // outside (GL base level -> GL max level) range.
      std::unique_ptr<NativeTextureWrapperWithViewSupport> mNativeTextureStorage;
      // The view of mNativeTextureStorage from (GL base level -> GL max level)
      std::unique_ptr<NativeTextureWrapper> mViewFromBaseToMaxLevel;
      id<MTLSamplerState> mMetalSamplerState = nil;
  
      // Number of slices
      uint32_t mSlices = 1;
  
      // Stored images array defined by glTexImage/glCopy*.
      // Once the images array is complete, they will be transferred to real texture object.
      // NOTE:
      //  - For Cube map, there will be at most 6 entries in the map table, one for each face. This is
      //  because the Cube map's image is defined per face & per level.
      //  - For other texture types, there will be only one entry in the map table. All other textures
      //  except Cube map has texture image defined per level (all slices included).
      //  - The second dimension is indexed by GL level.
      std::map<int, gl::TexLevelArray<ImageDefinitionMtl>> mTexImageDefs;
      // 1st index = image index, 2nd index = samples count.
      std::map<gl::ImageIndex, gl::RenderToTextureImageMap<RenderTargetMtl>> mRenderTargets;
      std::map<gl::ImageIndex, gl::RenderToTextureImageMap<mtl::TextureRef>> mImplicitMSTextures;
  
      // Lazily populated 2D views for shader storage images.
      // May have different formats than the original texture.
      // Indexed by format, then layer, then level.
      std::map<MTLPixelFormat, LayerLevelTextureViewVector> mShaderImageViews;
  
      // Mipmap views are indexed from (base GL level -> max GL level):
      mtl::NativeTexLevelArray mLevelViewsWithinBaseMax;
  
      // The swizzled or stencil view used for shader sampling.
      mtl::TextureRef mSwizzleStencilSamplingView;
  };
  
  }  // namespace rx
  
  #endif /* LIBANGLE_RENDERER_METAL_TEXTUREMTL_H_ */
  

Download