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

• Show log

  Commit

• Hash : e8528d89
  Author :
  Date : 2016-05-16T17:50:52
  

  Fix determining texture mipmap completeness
  
  The code didn't previously take base level properly into account
  when determining how many levels to check when checking for texture
  completeness.
  
  The code is refactored so that the "q" value in spec, that is the
  maximum mipmap level for determining completeness, can be queried from
  TextureState. This value is used now for checking completeness.
  
  This requires moving ImageDescs under TextureState. Functions that
  operate on the ImageDesc array are also moved from Texture to
  TextureState. TextureState members are also renamed to start with the
  "m" prefix and made private.
  
  Also handle levels outside the base/max level range consistently in
  eglCreateImageKHR validation. We interpret the spec so that if the
  level used for the EGL image is not a part of the texture levels that
  affect texture completeness, an error is generated.
  
  BUG=angleproject:596
  TEST=angle_end2end_tests
  
  Change-Id: I038ef24aa83e0a6905ca3c0bbada5989eecb00d9
  Reviewed-on: https://chromium-review.googlesource.com/344880
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/libANGLE/renderer/gl/TextureGL.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.
  //
  
  // TextureGL.h: Defines the class interface for TextureGL.
  
  #ifndef LIBANGLE_RENDERER_GL_TEXTUREGL_H_
  #define LIBANGLE_RENDERER_GL_TEXTUREGL_H_
  
  #include "libANGLE/angletypes.h"
  #include "libANGLE/renderer/TextureImpl.h"
  #include "libANGLE/Texture.h"
  
  namespace rx
  {
  
  class BlitGL;
  class FunctionsGL;
  class StateManagerGL;
  struct WorkaroundsGL;
  
  struct LUMAWorkaroundGL
  {
      bool enabled;
      GLenum workaroundFormat;
  
      LUMAWorkaroundGL();
      LUMAWorkaroundGL(bool enabled, GLenum workaroundFormat);
  };
  
  // Structure containing information about format and workarounds for each mip level of the
  // TextureGL.
  struct LevelInfoGL
  {
      // Format of the data used in this mip level.
      GLenum sourceFormat;
  
      // If this mip level requires sampler-state re-writing so that only a red channel is exposed.
      bool depthStencilWorkaround;
  
      // Information about luminance alpha texture workarounds in the core profile.
      LUMAWorkaroundGL lumaWorkaround;
  
      LevelInfoGL();
      LevelInfoGL(GLenum sourceFormat,
                  bool depthStencilWorkaround,
                  const LUMAWorkaroundGL &lumaWorkaround);
  };
  
  class TextureGL : public TextureImpl
  {
    public:
      TextureGL(const gl::TextureState &state,
                const FunctionsGL *functions,
                const WorkaroundsGL &workarounds,
                StateManagerGL *stateManager,
                BlitGL *blitter);
      ~TextureGL() override;
  
      gl::Error setImage(GLenum target, size_t level, GLenum internalFormat, const gl::Extents &size, GLenum format, GLenum type,
                         const gl::PixelUnpackState &unpack, const uint8_t *pixels) override;
      gl::Error setSubImage(GLenum target, size_t level, const gl::Box &area, GLenum format, GLenum type,
                            const gl::PixelUnpackState &unpack, const uint8_t *pixels) override;
  
      gl::Error setCompressedImage(GLenum target, size_t level, GLenum internalFormat, const gl::Extents &size,
                                   const gl::PixelUnpackState &unpack, size_t imageSize, const uint8_t *pixels) override;
      gl::Error setCompressedSubImage(GLenum target, size_t level, const gl::Box &area, GLenum format,
                                      const gl::PixelUnpackState &unpack, size_t imageSize, const uint8_t *pixels) override;
  
      gl::Error copyImage(GLenum target, size_t level, const gl::Rectangle &sourceArea, GLenum internalFormat,
                          const gl::Framebuffer *source) override;
      gl::Error copySubImage(GLenum target, size_t level, const gl::Offset &destOffset, const gl::Rectangle &sourceArea,
                             const gl::Framebuffer *source) override;
  
      gl::Error setStorage(GLenum target, size_t levels, GLenum internalFormat, const gl::Extents &size) override;
  
      gl::Error setImageExternal(GLenum target,
                                 egl::Stream *stream,
                                 const egl::Stream::GLTextureDescription &desc) override;
  
      gl::Error generateMipmaps() override;
  
      void bindTexImage(egl::Surface *surface) override;
      void releaseTexImage() override;
  
      gl::Error setEGLImageTarget(GLenum target, egl::Image *image) override;
  
      void syncState(size_t textureUnit) const;
      GLuint getTextureID() const;
  
      gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
                                          FramebufferAttachmentRenderTarget **rtOut) override
      {
          return gl::Error(GL_OUT_OF_MEMORY, "Not supported on OpenGL");
      }
  
      void setBaseLevel(GLuint) override {}
  
    private:
      const FunctionsGL *mFunctions;
      const WorkaroundsGL &mWorkarounds;
      StateManagerGL *mStateManager;
      BlitGL *mBlitter;
  
      std::vector<LevelInfoGL> mLevelInfo;
  
      mutable gl::TextureState mAppliedTextureState;
      GLuint mTextureID;
  };
  
  }
  
  #endif // LIBANGLE_RENDERER_GL_TEXTUREGL_H_
  

Download