Branch
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>
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
//
// Copyright 2020 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.
//
// PixmapSurfaceGLX.cpp: GLX implementation of egl::Surface for Pixmaps
#include "common/debug.h"
#include "libANGLE/Display.h"
#include "libANGLE/Surface.h"
#include "libANGLE/renderer/gl/glx/DisplayGLX.h"
#include "libANGLE/renderer/gl/glx/FunctionsGLX.h"
#include "libANGLE/renderer/gl/glx/PixmapSurfaceGLX.h"
#include "libANGLE/renderer/gl/glx/glx_utils.h"
#include <iostream>
namespace rx
{
namespace
{
int EGLTextureFormatToGLXTextureFormat(EGLint textureFormat)
{
switch (textureFormat)
{
case EGL_NO_TEXTURE:
return GLX_TEXTURE_FORMAT_NONE_EXT;
case EGL_TEXTURE_RGB:
return GLX_TEXTURE_FORMAT_RGB_EXT;
case EGL_TEXTURE_RGBA:
return GLX_TEXTURE_FORMAT_RGBA_EXT;
default:
UNREACHABLE();
return GLX_TEXTURE_FORMAT_NONE_EXT;
}
}
int EGLTextureTargetToGLXTextureTarget(EGLint textureTarget)
{
switch (textureTarget)
{
case EGL_NO_TEXTURE:
return 0;
case EGL_TEXTURE_2D:
return GLX_TEXTURE_2D_EXT;
default:
UNREACHABLE();
return 0;
}
}
int EGLBufferToGLXBuffer(EGLint buffer)
{
switch (buffer)
{
case EGL_BACK_BUFFER:
return GLX_BACK_EXT;
default:
UNREACHABLE();
return 0;
}
}
} // namespace
PixmapSurfaceGLX::PixmapSurfaceGLX(const egl::SurfaceState &state,
Pixmap pixmap,
Display *display,
const FunctionsGLX &glx,
glx::FBConfig fbConfig)
: SurfaceGLX(state),
mWidth(0),
mHeight(0),
mGLX(glx),
mFBConfig(fbConfig),
mXPixmap(pixmap),
mGLXPixmap(0),
mDisplay(display)
{}
PixmapSurfaceGLX::~PixmapSurfaceGLX()
{
if (mGLXPixmap)
{
mGLX.destroyPixmap(mGLXPixmap);
}
}
egl::Error PixmapSurfaceGLX::initialize(const egl::Display *display)
{
DisplayGLX *displayGLX = GetImplAs<DisplayGLX>(display);
{
Window rootWindow;
int x = 0;
int y = 0;
unsigned int borderWidth = 0;
unsigned int depth = 0;
int status = XGetGeometry(mDisplay, mXPixmap, &rootWindow, &x, &y, &mWidth, &mHeight,
&borderWidth, &depth);
if (!status)
{
return egl::Error(EGL_BAD_SURFACE, "XGetGeometry query failed on pixmap surface: " +
x11::XErrorToString(mDisplay, status));
}
}
std::vector<int> pixmapAttribs;
if (mState.attributes.contains(EGL_TEXTURE_FORMAT))
{
pixmapAttribs.push_back(GLX_TEXTURE_FORMAT_EXT);
pixmapAttribs.push_back(
EGLTextureFormatToGLXTextureFormat(mState.attributes.getAsInt(EGL_TEXTURE_FORMAT)));
}
if (mState.attributes.contains(EGL_TEXTURE_TARGET))
{
pixmapAttribs.push_back(GLX_TEXTURE_TARGET_EXT);
pixmapAttribs.push_back(
EGLTextureTargetToGLXTextureTarget(mState.attributes.getAsInt(EGL_TEXTURE_TARGET)));
}
pixmapAttribs.push_back(None);
mGLXPixmap = mGLX.createPixmap(mFBConfig, mXPixmap, pixmapAttribs.data());
if (!mGLXPixmap)
{
return egl::Error(EGL_BAD_ALLOC, "Failed to create a native GLX pixmap.");
}
XFlush(mDisplay);
displayGLX->syncXCommands(false);
return egl::NoError();
}
egl::Error PixmapSurfaceGLX::makeCurrent(const gl::Context *context)
{
return egl::NoError();
}
egl::Error PixmapSurfaceGLX::swap(const gl::Context *context, SurfaceSwapFeedback *feedback)
{
UNREACHABLE();
return egl::NoError();
}
egl::Error PixmapSurfaceGLX::postSubBuffer(const gl::Context *context,
EGLint x,
EGLint y,
EGLint width,
EGLint height)
{
UNREACHABLE();
return egl::NoError();
}
egl::Error PixmapSurfaceGLX::querySurfacePointerANGLE(EGLint attribute, void **value)
{
UNREACHABLE();
return egl::NoError();
}
egl::Error PixmapSurfaceGLX::bindTexImage(const gl::Context *context,
gl::Texture *texture,
EGLint buffer)
{
const int attribs[] = {None};
mGLX.bindTexImageEXT(mGLXPixmap, EGLBufferToGLXBuffer(buffer), attribs);
return egl::NoError();
}
egl::Error PixmapSurfaceGLX::releaseTexImage(const gl::Context *context, EGLint buffer)
{
mGLX.releaseTexImageEXT(mGLXPixmap, EGLBufferToGLXBuffer(buffer));
return egl::NoError();
}
void PixmapSurfaceGLX::setSwapInterval(const egl::Display *display, EGLint interval) {}
gl::Extents PixmapSurfaceGLX::getSize() const
{
return gl::Extents(mWidth, mHeight, 1);
}
EGLint PixmapSurfaceGLX::isPostSubBufferSupported() const
{
UNREACHABLE();
return EGL_FALSE;
}
EGLint PixmapSurfaceGLX::getSwapBehavior() const
{
return EGL_BUFFER_DESTROYED;
}
egl::Error PixmapSurfaceGLX::checkForResize()
{
// The size of pbuffers never change
return egl::NoError();
}
glx::Drawable PixmapSurfaceGLX::getDrawable() const
{
return mGLXPixmap;
}
} // namespace rx