kc3-lang/angle/src/libANGLE/renderer/SurfaceImpl.h

• Show log

  Commit

• Hash : 5fd368aa
  Author :
  Date : 2025-07-30T14:45:55
  

  Replace Surface::getWidth/Height() with getSize()
  
  Most places in the code use both `getWidth/Height()` methods at the same
  time. On some back-ends it is more optimal to have single method.
  For example, `WindowSurfaceWGL` first uses `GetClientRect()` Win32 API
  inside each method to then calculate width and hight in each method,
  causing repeated `GetClientRect()` call.
  
  The only place where only one of the methods may be used is from
  `SurfaceImpl::getUserSize()` when one of the parameters is `nullptr`,
  which is only possible from `QuerySurfaceAttrib()` function. This
  method is rewritten to use new `getSize()` method and then use whatever
  dimensions is requested by the caller. This may cause
  `QuerySurfaceAttrib()` inefficiency on some back-ends that get width and
  height of the surface differently (`SurfaceEGL` for example). In such
  cases `getUserSize()` is overridden to avoid returning a dimension
  which is not required.
  
  After this change all places in the code that previously used both
  `getWidth/Height()` methods (like `Surface::getAttachmentSize()`) will
  be more efficient. The `QuerySurfaceAttrib()`, on the other hand, will
  have slightly more overhead on back-ends where base
  `SurfaceImpl::getUserSize()` method is used, which only happens on
  back-ends with trivial `getSize()` implementation.
  
  Bug: angleproject:397848903
  Change-Id: I4a22701a1e62ee4e7d07e77cac5b388050d98e4d
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6802440
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
  

Download

• src/libANGLE/renderer/SurfaceImpl.h

• //
  // Copyright 2014 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.
  //
  
  // SurfaceImpl.h: Implementation methods of egl::Surface
  
  #ifndef LIBANGLE_RENDERER_SURFACEIMPL_H_
  #define LIBANGLE_RENDERER_SURFACEIMPL_H_
  
  #include <EGL/egl.h>
  #include <EGL/eglext.h>
  
  #include "common/angleutils.h"
  #include "libANGLE/Error.h"
  #include "libANGLE/FramebufferAttachment.h"
  #include "libANGLE/renderer/FramebufferAttachmentObjectImpl.h"
  
  namespace angle
  {
  struct Format;
  }
  
  namespace gl
  {
  class Context;
  class FramebufferState;
  }  // namespace gl
  
  namespace egl
  {
  class Display;
  struct Config;
  struct SurfaceState;
  class Thread;
  
  using SupportedTimestamps        = angle::PackedEnumBitSet<Timestamp>;
  using SupportedCompositorTimings = angle::PackedEnumBitSet<CompositorTiming>;
  }  // namespace egl
  
  namespace rx
  {
  struct SurfaceSwapFeedback
  {
      bool swapChainImageChanged = false;
  };
  
  class SurfaceImpl : public FramebufferAttachmentObjectImpl
  {
    public:
      SurfaceImpl(const egl::SurfaceState &surfaceState);
      ~SurfaceImpl() override;
      virtual void destroy(const egl::Display *display) {}
  
      virtual egl::Error initialize(const egl::Display *display) = 0;
      virtual egl::Error makeCurrent(const gl::Context *context);
      virtual egl::Error unMakeCurrent(const gl::Context *context);
      virtual egl::Error prepareSwap(const gl::Context *);
      virtual egl::Error swap(const gl::Context *context, SurfaceSwapFeedback *feedback) = 0;
      virtual egl::Error swapWithDamage(const gl::Context *context,
                                        const EGLint *rects,
                                        EGLint n_rects,
                                        SurfaceSwapFeedback *feedback);
      virtual egl::Error postSubBuffer(const gl::Context *context,
                                       EGLint x,
                                       EGLint y,
                                       EGLint width,
                                       EGLint height);
      virtual egl::Error setPresentationTime(EGLnsecsANDROID time);
      virtual egl::Error querySurfacePointerANGLE(EGLint attribute, void **value);
      virtual egl::Error bindTexImage(const gl::Context *context,
                                      gl::Texture *texture,
                                      EGLint buffer)                                = 0;
      virtual egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) = 0;
      virtual egl::Error getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc);
      virtual egl::Error getMscRate(EGLint *numerator, EGLint *denominator);
      virtual void setSwapInterval(const egl::Display *display, EGLint interval) = 0;
      virtual void setFixedWidth(EGLint width);
      virtual void setFixedHeight(EGLint height);
  
      // Explicitly resolves surface size to use before state synchronization (e.g. validation).
      virtual angle::Result ensureSizeResolved(const gl::Context *context);
      // size can change with client window resizing
      // Size must be resolved before the call either during state synchronization or explicitly.
      virtual gl::Extents getSize() const = 0;
      // Unresolved Surface size until render target is first accessed (e.g. after draw).
      virtual egl::Error getUserSize(const egl::Display *display,
                                     EGLint *width,
                                     EGLint *height) const;
  
      virtual EGLint isPostSubBufferSupported() const;
      virtual EGLint getSwapBehavior() const = 0;
  
      virtual egl::Error attachToFramebuffer(const gl::Context *context,
                                             gl::Framebuffer *framebuffer)   = 0;
      virtual egl::Error detachFromFramebuffer(const gl::Context *context,
                                               gl::Framebuffer *framebuffer) = 0;
  
      // Used to query color format from pbuffers created from D3D and WebGPU textures.
      virtual const angle::Format *getClientBufferTextureColorFormat() const;
  
      // EGL_ANDROID_get_frame_timestamps
      virtual void setTimestampsEnabled(bool enabled);
      virtual egl::SupportedCompositorTimings getSupportedCompositorTimings() const;
      virtual egl::Error getCompositorTiming(EGLint numTimestamps,
                                             const EGLint *names,
                                             EGLnsecsANDROID *values) const;
      virtual egl::Error getNextFrameId(EGLuint64KHR *frameId) const;
      virtual egl::SupportedTimestamps getSupportedTimestamps() const;
      virtual egl::Error getFrameTimestamps(EGLuint64KHR frameId,
                                            EGLint numTimestamps,
                                            const EGLint *timestamps,
                                            EGLnsecsANDROID *values) const;
      virtual egl::Error getBufferAge(const gl::Context *context, EGLint *age);
  
      // EGL_ANDROID_front_buffer_auto_refresh
      virtual egl::Error setAutoRefreshEnabled(bool enabled);
  
      // EGL_KHR_lock_surface3
      virtual egl::Error lockSurface(const egl::Display *display,
                                     EGLint usageHint,
                                     bool preservePixels,
                                     uint8_t **bufferPtrOut,
                                     EGLint *bufferPitchOut);
      virtual egl::Error unlockSurface(const egl::Display *display, bool preservePixels);
      virtual EGLint origin() const;
  
      virtual egl::Error setRenderBuffer(EGLint renderBuffer);
  
      virtual egl::Error getCompressionRate(const egl::Display *display,
                                            const gl::Context *context,
                                            EGLint *rate);
  
      virtual bool supportsSingleRenderBuffer() const;
  
    protected:
      const egl::SurfaceState &mState;
  };
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_SURFACEIMPL_H_
  

Download