gpu/command_buffer/service/gl_utils.h

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// This file includes all the necessary GL headers and implements some useful
// utilities.

#ifndef GPU_COMMAND_BUFFER_SERVICE_GL_UTILS_H_
#define GPU_COMMAND_BUFFER_SERVICE_GL_UTILS_H_

#include <string>

#include "base/containers/flat_map.h"
#include "base/containers/flat_set.h"
#include "base/containers/span.h"
#include "build/build_config.h"
#include "components/viz/common/resources/shared_image_format.h"
#include "gpu/command_buffer/common/constants.h"
#include "gpu/gpu_gles2_export.h"
#include "ui/gfx/buffer_types.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/rrect_f.h"
#include "ui/gfx/geometry/transform.h"
#include "ui/gfx/geometry/vector2d.h"
#include "ui/gfx/overlay_transform.h"
#include "ui/gl/gl_bindings.h"

// Define this for extra GL error debugging (slower).
// #define GL_ERROR_DEBUGGING
#ifdef GL_ERROR_DEBUGGING
#define CHECK_GL_ERROR()                                                \
  do {                                                                  \
    GLenum gl_error = glGetError();                                     \
    LOG_IF(ERROR, gl_error != GL_NO_ERROR) << "GL Error :" << gl_error; \
  } while (0)
#else  // GL_ERROR_DEBUGGING
#define CHECK_GL_ERROR() void(0)
#endif  // GL_ERROR_DEBUGGING

namespace gpu {

struct Capabilities;
struct GLCapabilities;

namespace gles2 {

class ErrorState;
class FeatureInfo;
class Logger;
class Texture;
enum class CopyTextureMethod;

// clang-format off
constexpr GLfloat kIdentityMatrix[16] = { 1.0f, 0.0f, 0.0f, 0.0f,
                                          0.0f, 1.0f, 0.0f, 0.0f,
                                          0.0f, 0.0f, 1.0f, 0.0f,
                                          0.0f, 0.0f, 0.0f, 1.0f };
// clang-format on

struct CALayerSharedState {
  float opacity;
  bool is_clipped;
  gfx::Rect clip_rect;
  gfx::RRectF rounded_corner_bounds;
  int sorting_context_id;
  gfx::Transform transform;
};

bool PrecisionMeetsSpecForHighpFloat(GLint rangeMin,
                                     GLint rangeMax,
                                     GLint precision);
void QueryShaderPrecisionFormat(GLenum shader_type,
                                GLenum precision_type,
                                base::span<GLint> range,
                                GLint* precision);

// Using the provided feature info, query the numeric limits of the underlying
// GL and fill in the members of the Capabilities struct.  Does not perform any
// extension checks.
void PopulateNumericCapabilities(Capabilities* caps,
                                 const FeatureInfo* feature_info);

// Using the provided feature info, query the numeric limits of the underlying
// GL and fill in the members of the GLCapabilities struct.  Does not perform
// any extension checks.
void PopulateGLCapabilities(GLCapabilities* caps,
                            const FeatureInfo* feature_info);

#if BUILDFLAG(IS_CHROMEOS)
// Validate the list of formats `drm_formats_and_modifiers` only contains valid
// drm formats that are mappable for Exo on ChromeOS. Provide fallback list of
// mappable formats with invalid modifiers, if it is empty.
void PopulateMappableDrmFormatsForExo(
    base::flat_map<uint32_t, std::vector<uint64_t>>& drm_formats_and_modifiers,
    const FeatureInfo* feature_info);
void PopulateDRMCapabilities(Capabilities* caps,
                             const FeatureInfo* feature_info);
#endif

bool CheckUniqueAndNonNullIds(GLsizei n, const GLuint* client_ids);

const char* GetServiceVersionString(const FeatureInfo* feature_info);
const char* GetServiceShadingLanguageVersionString(
    const FeatureInfo* feature_info);

void LogGLDebugMessage(GLenum source,
                       GLenum type,
                       GLuint id,
                       GLenum severity,
                       GLsizei length,
                       const GLchar* message,
                       Logger* error_logger);
GPU_GLES2_EXPORT void InitializeGLDebugLogging(bool log_non_errors,
                                               GLDEBUGPROC callback,
                                               const void* user_param);

bool ValidContextLostReason(GLenum reason);
error::ContextLostReason GetContextLostReasonFromResetStatus(
    GLenum reset_status);

GPU_GLES2_EXPORT gfx::Vector2d GetCompressedTexBlockDimensions(GLenum format);

bool GetCompressedTexSizeInBytes(const char* function_name,
                                 GLsizei width,
                                 GLsizei height,
                                 GLsizei depth,
                                 GLenum format,
                                 GLsizei* size_in_bytes,
                                 ErrorState* error_state);

bool ValidateCompressedFormatTarget(GLenum target, GLenum format);

bool ValidateCompressedTexSubDimensions(GLenum target,
                                        GLint level,
                                        GLint xoffset,
                                        GLint yoffset,
                                        GLint zoffset,
                                        GLsizei width,
                                        GLsizei height,
                                        GLsizei depth,
                                        GLenum format,
                                        Texture* texture,
                                        const char** error_message);

bool ValidateCompressedTexDimensions(GLenum target,
                                     GLint level,
                                     GLsizei width,
                                     GLsizei height,
                                     GLsizei depth,
                                     GLenum format,
                                     const char** error_message);

bool ValidateCopyTexFormatHelper(const FeatureInfo* feature_info,
                                 GLenum internal_format,
                                 GLenum read_format,
                                 GLenum read_type,
                                 std::string* output_error_msg);

CopyTextureMethod GetCopyTextureCHROMIUMMethod(const FeatureInfo* feature_info,
                                               GLenum source_target,
                                               GLint source_level,
                                               GLenum source_internal_format,
                                               GLenum source_type,
                                               GLenum dest_target,
                                               GLint dest_level,
                                               GLenum dest_internal_format,
                                               bool flip_y,
                                               bool premultiply_alpha,
                                               bool unpremultiply_alpha);

bool ValidateCopyTextureCHROMIUMInternalFormats(const FeatureInfo* feature_info,
                                                GLenum source_internal_format,
                                                GLenum dest_internal_format,
                                                std::string* output_error_msg);

GLenum GetTextureBindingQuery(GLenum texture_type);

gfx::OverlayTransform GetGFXOverlayTransform(GLenum plane_transform);

bool IsASTCFormat(GLenum internal_format);
bool IsCompressedTextureFormat(GLenum internal_format);

Texture* CreateGLES2TextureWithLightRef(GLuint service_id, GLenum target);

}  // namespace gles2

// Drains all GL errors from `gl_api` and returns the first error encountered,
// or GL_NO_ERROR if there were no errors or `gl_api` is null.
inline GLenum DrainGLErrors(gl::GLApi* gl_api) {
  if (!gl_api) {
    return GL_NO_ERROR;
  }
  GLenum error = gl_api->glGetErrorFn();
  GLenum first_error = error;
  while (error != GL_NO_ERROR) {
    error = gl_api->glGetErrorFn();
  }
  return first_error;
}

}  // namespace gpu

#endif  // GPU_COMMAND_BUFFER_SERVICE_GL_UTILS_H_