kc3-lang/angle/src/libANGLE/renderer/gl/formatutilsgl.h

• Show log

  Commit

• Hash : fb7a2445
  Author :
  Date : 2021-02-12T09:29:11
  

  libANGLE: Declare copy operator if copy constructor is defined
  
  If the copy constructor is defined then the copy assignment
  must also be defined, but we can use the default here.
  
  v2: Don't inline because the chromium-style errors out on this
  
  Bug: angleproject:4486
  Change-Id: Iec0f63342244249da32b455b49a0b89b6558cab9
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2690953
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/renderer/gl/formatutilsgl.h

• //
  // Copyright 2015 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.
  //
  
  // formatutilsgl.h: Queries for GL image formats and their translations to native
  // GL formats.
  
  #ifndef LIBANGLE_RENDERER_GL_FORMATUTILSGL_H_
  #define LIBANGLE_RENDERER_GL_FORMATUTILSGL_H_
  
  #include <map>
  #include <string>
  #include <vector>
  
  #include "angle_gl.h"
  #include "libANGLE/Version.h"
  #include "libANGLE/renderer/gl/FunctionsGL.h"
  
  namespace angle
  {
  struct FeaturesGL;
  }  // namespace angle
  
  namespace rx
  {
  
  namespace nativegl
  {
  
  struct SupportRequirement
  {
      SupportRequirement();
      SupportRequirement(const SupportRequirement &other);
      SupportRequirement &operator=(const SupportRequirement &other);
  
      ~SupportRequirement();
  
      // Version that this format became supported without extensions
      gl::Version version;
  
      // Extensions that are required if the minimum version is not met
      std::vector<std::string> versionExtensions;
  
      // Sets of extensions that are required to support this format
      // All the extensions in one of the sets have to be available for a format to be supported
      std::vector<std::vector<std::string>> requiredExtensions;
  };
  
  struct InternalFormat
  {
      InternalFormat();
      InternalFormat(const InternalFormat &other);
      ~InternalFormat();
  
      SupportRequirement texture;
      SupportRequirement filter;
      // Texture created with InternalFormat can be used in glFramebufferTexture2D
      SupportRequirement textureAttachment;
      // Renderbuffer created with InternalFormat can be used in glFramebufferRenderbuffer
      SupportRequirement renderbuffer;
  };
  const InternalFormat &GetInternalFormatInfo(GLenum internalFormat, StandardGL standard);
  
  struct TexImageFormat
  {
      GLenum internalFormat = GL_NONE;
      GLenum format         = GL_NONE;
      GLenum type           = GL_NONE;
  };
  TexImageFormat GetTexImageFormat(const FunctionsGL *functions,
                                   const angle::FeaturesGL &features,
                                   GLenum internalFormat,
                                   GLenum format,
                                   GLenum type);
  
  struct TexSubImageFormat
  {
      GLenum format = GL_NONE;
      GLenum type   = GL_NONE;
  };
  TexSubImageFormat GetTexSubImageFormat(const FunctionsGL *functions,
                                         const angle::FeaturesGL &features,
                                         GLenum format,
                                         GLenum type);
  
  struct CompressedTexImageFormat
  {
      GLenum internalFormat = GL_NONE;
  };
  CompressedTexImageFormat GetCompressedTexImageFormat(const FunctionsGL *functions,
                                                       const angle::FeaturesGL &features,
                                                       GLenum internalFormat);
  
  struct CompressedTexSubImageFormat
  {
      GLenum format = GL_NONE;
  };
  CompressedTexSubImageFormat GetCompressedSubTexImageFormat(const FunctionsGL *functions,
                                                             const angle::FeaturesGL &features,
                                                             GLenum format);
  
  struct CopyTexImageImageFormat
  {
      GLenum internalFormat = GL_NONE;
  };
  CopyTexImageImageFormat GetCopyTexImageImageFormat(const FunctionsGL *functions,
                                                     const angle::FeaturesGL &features,
                                                     GLenum internalFormat,
                                                     GLenum framebufferType);
  
  struct TexStorageFormat
  {
      GLenum internalFormat = GL_NONE;
  };
  TexStorageFormat GetTexStorageFormat(const FunctionsGL *functions,
                                       const angle::FeaturesGL &features,
                                       GLenum internalFormat);
  
  struct RenderbufferFormat
  {
      GLenum internalFormat = GL_NONE;
  };
  RenderbufferFormat GetRenderbufferFormat(const FunctionsGL *functions,
                                           const angle::FeaturesGL &features,
                                           GLenum internalFormat);
  
  struct ReadPixelsFormat
  {
      GLenum format = GL_NONE;
      GLenum type   = GL_NONE;
  };
  ReadPixelsFormat GetReadPixelsFormat(const FunctionsGL *functions,
                                       const angle::FeaturesGL &features,
                                       GLenum readAttachmentFormat,
                                       GLenum format,
                                       GLenum type);
  }  // namespace nativegl
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_GL_FORMATUTILSGL_H_
  

Download