// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "android_webview/browser/gfx/aw_gl_surface_external_stencil.h"
#include "android_webview/browser/gfx/scoped_app_gl_state_restore.h"
#include "base/feature_list.h"
#include "base/strings/stringize_macros.h"
#include "ui/gfx/geometry/quad_f.h"
#include "ui/gl/gl_bindings.h"
#include "ui/gl/gl_helper.h"
namespace android_webview {
// Lifetime: WebView
class AwGLSurfaceExternalStencil::BlitContext {
public:
BlitContext() {
// NOTE: Quad is flipped vertically.
// clang-format off
const GLchar vertex_shader_str[] =
STRINGIZE(
attribute vec2 position;
attribute vec2 texcoords;
varying vec2 v_texcoords;
void main()
{
v_texcoords = vec2(texcoords.x, 1.0 - texcoords.y);
vec2 pos = position * 2.0 - vec2(1.0);
gl_Position = vec4(pos.x, -pos.y, 0.0, 1.0);
}
);
const GLchar fragment_shader_str[] =
STRINGIZE(
precision mediump float;
varying vec2 v_texcoords;
uniform sampler2D texture;
void main()
{
gl_FragColor = texture2D ( texture, v_texcoords );
}
);
// clang-format on
GLuint vertex_shader =
gl::GLHelper::LoadShader(GL_VERTEX_SHADER, vertex_shader_str);
GLuint fragment_shader =
gl::GLHelper::LoadShader(GL_FRAGMENT_SHADER, fragment_shader_str);
program_ = glCreateProgram();
glAttachShader(program_, vertex_shader);
glAttachShader(program_, fragment_shader);
glBindAttribLocation(program_, 0, "position");
glBindAttribLocation(program_, 1, "texcoords");
glLinkProgram(program_);
GLint linked;
glGetProgramiv(program_, GL_LINK_STATUS, &linked);
DCHECK(linked);
glDeleteShader(vertex_shader);
glDeleteShader(fragment_shader);
texture_uniform_ = glGetUniformLocation(program_, "texture");
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &gl_max_vertex_attribs_);
}
~BlitContext() { glDeleteProgram(program_); }
void Bind() {
// If vertex array objects are supported we need to reset it to default one,
// so we won't break someones else VAS by changing attributes.
if (gl::g_current_gl_driver->fn.glBindVertexArrayOESFn) {
glBindVertexArrayOES(0);
}
glUseProgram(program_);
for (GLint i = 2; i < gl_max_vertex_attribs_; ++i) {
glDisableVertexAttribArray(i);
}
// Note that function is not ANGLE only.
if (gl::g_current_gl_driver->fn.glVertexAttribDivisorANGLEFn) {
glVertexAttribDivisorANGLE(0, 0);
glVertexAttribDivisorANGLE(1, 0);
}
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glUniform1i(texture_uniform_, 0);
}
private:
GLuint program_;
GLint texture_uniform_;
GLint gl_max_vertex_attribs_;
};
// Lifetime: WebView
class AwGLSurfaceExternalStencil::FrameBuffer {
public:
FrameBuffer(gfx::Size size) : size_(size) {
glGenTextures(1, &texture_id_);
glBindTexture(GL_TEXTURE_2D, texture_id_);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size.width(), size.height(), 0,
GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D, 0);
glGenFramebuffersEXT(1, &frame_buffer_object_);
glBindFramebufferEXT(GL_FRAMEBUFFER, frame_buffer_object_);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, texture_id_, 0);
DCHECK(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER) ==
GL_FRAMEBUFFER_COMPLETE)
<< "Failed to set up framebuffer for WebView GL drawing.";
}
void Clear() {
glBindFramebufferEXT(GL_FRAMEBUFFER, frame_buffer_object_);
glDisable(GL_SCISSOR_TEST);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
}
~FrameBuffer() {
glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
glBindTexture(GL_TEXTURE_2D, 0);
if (frame_buffer_object_)
glDeleteFramebuffersEXT(1, &frame_buffer_object_);
if (texture_id_)
glDeleteTextures(1, &texture_id_);
}
GLuint frame_buffer_object() const { return frame_buffer_object_; }
GLuint texture_id() const { return texture_id_; }
gfx::Size size() const { return size_; }
private:
GLuint frame_buffer_object_ = 0;
GLuint texture_id_ = 0;
gfx::Size size_;
};
AwGLSurfaceExternalStencil::AwGLSurfaceExternalStencil(
gl::GLDisplayEGL* display,
bool is_angle)
: AwGLSurface(display, is_angle) {}
AwGLSurfaceExternalStencil::~AwGLSurfaceExternalStencil() {
InvalidateWeakPtrs();
}
unsigned int AwGLSurfaceExternalStencil::GetBackingFramebufferObject() {
const auto& stencil_state =
android_webview::ScopedAppGLStateRestore::Current()->stencil_state();
if (stencil_state.stencil_test_enabled) {
// Framebuffer was created during RecalculateClipAndTransform();
DCHECK(framebuffer_);
return framebuffer_->frame_buffer_object();
}
return AwGLSurface::GetBackingFramebufferObject();
}
gfx::SwapResult AwGLSurfaceExternalStencil::SwapBuffers(
PresentationCallback callback,
gfx::FrameData frame_data) {
const auto& stencil_state =
android_webview::ScopedAppGLStateRestore::Current()->stencil_state();
if (stencil_state.stencil_test_enabled) {
DCHECK(framebuffer_);
DCHECK(blit_context_);
// Flush skia renderer rendering. This is working around what appears to be
// a driver bug that causes rendering to break.
glFlush();
// Bind required context.
blit_context_->Bind();
// Bind real frame buffer.
glBindFramebufferEXT(GL_FRAMEBUFFER,
AwGLSurface::GetBackingFramebufferObject());
// Restore stencil state.
glEnable(GL_STENCIL_TEST);
glStencilFuncSeparate(GL_FRONT, stencil_state.stencil_front_func,
stencil_state.stencil_front_ref,
stencil_state.stencil_front_mask);
glStencilFuncSeparate(GL_BACK, stencil_state.stencil_back_func,
stencil_state.stencil_back_ref,
stencil_state.stencil_back_mask);
glStencilMaskSeparate(GL_FRONT, stencil_state.stencil_front_writemask);
glStencilMaskSeparate(GL_BACK, stencil_state.stencil_back_writemask);
glStencilOpSeparate(GL_FRONT, stencil_state.stencil_front_fail_op,
stencil_state.stencil_front_z_fail_op,
stencil_state.stencil_front_z_pass_op);
glStencilOpSeparate(GL_BACK, stencil_state.stencil_back_fail_op,
stencil_state.stencil_back_z_fail_op,
stencil_state.stencil_back_z_pass_op);
// Scale clip rect to (0, 0)x(1, 1) space.
gfx::QuadF quad = gfx::QuadF(gfx::RectF(clip_rect_));
quad.Scale(1.0 / viewport_.width(), 1.0 / viewport_.height());
gfx::QuadF tex_quad = gfx::QuadF(gfx::RectF(1.0, 1.0));
// Set-up vertex attributes. p1-p4-p2-p3 forms triangle strip for quad.
// clang-format off
const gfx::PointF data[8] = {quad.p1(), tex_quad.p1(),
quad.p4(), tex_quad.p4(),
quad.p2(), tex_quad.p2(),
quad.p3(), tex_quad.p3()};
// clang-format on
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(gfx::PointF) * 2,
&data[1]);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(gfx::PointF) * 2,
&data[0]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, framebuffer_->texture_id());
if (gl::g_current_gl_driver->fn.glBindSamplerFn)
glBindSampler(0, 0);
// We need to restore viewport as it might have changed by renderer
glViewport(0, 0, viewport_.width(), viewport_.height());
// We draw only inside clip rect, no need to scissor.
glDisable(GL_SCISSOR_TEST);
// Restore color mask in case.
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
// Restore blending.
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glFrontFace(GL_CCW);
if (gl::g_current_gl_driver->fn.glWindowRectanglesEXTFn)
glWindowRectanglesEXT(GL_EXCLUSIVE_EXT, 0, nullptr);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
return AwGLSurface::SwapBuffers(std::move(callback), std::move(frame_data));
}
void AwGLSurfaceExternalStencil::RecalculateClipAndTransform(
gfx::Size* viewport,
gfx::Rect* clip_rect,
gfx::Transform* transform) {
clip_rect_ = *clip_rect;
viewport_ = *viewport;
const auto& stencil_state =
android_webview::ScopedAppGLStateRestore::Current()->stencil_state();
if (stencil_state.stencil_test_enabled) {
// Initialize graphics part needed for blit with stencil here so we don't
// change any gl state after GrContext reset after this function call.
if (!blit_context_) {
blit_context_ = std::make_unique<BlitContext>();
}
if (!framebuffer_ || framebuffer_->size() != clip_rect_.size()) {
// Delete old one first to reduce peak memory.
framebuffer_.reset();
framebuffer_ = std::make_unique<FrameBuffer>(clip_rect_.size());
}
framebuffer_->Clear();
// Adjust transform, clip rect and viewport to be in original clip rect
// space as we will draw to FBO of clip_rect size and blit it to screen at
// original location.
transform->PostTranslate(-clip_rect->x(), -clip_rect->y());
clip_rect->set_origin(gfx::Point(0, 0));
*viewport = clip_rect_.size();
} else {
// We're not going to draw to frame buffer, so we can free it to save
// memory, assuming |stencil_test_enabled| doesn't change often.
framebuffer_.reset();
}
}
bool AwGLSurfaceExternalStencil::IsDrawingToFBO() {
const auto& stencil_state =
android_webview::ScopedAppGLStateRestore::Current()->stencil_state();
return stencil_state.stencil_test_enabled;
}
void AwGLSurfaceExternalStencil::DestroyExternalStencilFramebuffer() {
framebuffer_.reset();
blit_context_.reset();
}
} // namespace android_webview
Codebase Browser
chromium