bcarrella
/
cef
mirror of https://bitbucket.org/chromiumembedded/cef
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
cef/tests/cefclient/browser/osr_renderer.cc

1099 lines
28 KiB
C++
Raw Blame History

// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license
// that can be found in the LICENSE file.
#include "tests/cefclient/browser/osr_renderer.h"
#if defined(__clang__)
// Begin disable NSOpenGL deprecation warnings.
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
#endif
#if USE_SHADERS
// Expose prototypes for OpenGL shader functions.
#define GL_GLEXT_PROTOTYPES
#endif
#include <math.h>
#if defined(OS_WIN)
#include <gl/gl.h>
#elif defined(OS_MAC)
#if USE_SHADERS
#include <OpenGL/gl3.h>
#else
#include <OpenGL/gl.h>
#endif
#elif defined(OS_LINUX)
#include <GL/gl.h>
#else
#error Platform is not supported.
#endif
#include "include/base/cef_logging.h"
#include "include/wrapper/cef_helpers.h"
#ifndef GL_BGR
#define GL_BGR 0x80E0
#endif
#ifndef GL_BGRA
#define GL_BGRA 0x80E1
#endif
#ifndef GL_UNSIGNED_INT_8_8_8_8_REV
#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
#endif
// DCHECK on gl errors.
#if DCHECK_IS_ON()
#define VERIFY_NO_ERROR \
{ \
int _gl_error = glGetError(); \
DCHECK(_gl_error == GL_NO_ERROR) << "glGetError returned " << _gl_error; \
}
#else
#define VERIFY_NO_ERROR
#endif
namespace client {
#if USE_SHADERS
namespace {
const char* kScreenVertexShader =
"#version 330 core\n"
"out vec2 texCoord;\n"
"uniform mat4 transform;\n"
"void main() {\n"
"\tfloat x = float(((uint(gl_VertexID) + 2u) / 3u)\%2u);\n"
"\tfloat y = float(((uint(gl_VertexID) + 1u) / 3u)\%2u);\n"
"\tvec4 pos = vec4(-1.0f + x*2.0f, -1.0f + y*2.0f, 0.0f, 1.0f);\n"
"\tgl_Position = transform * pos;\n"
"\ttexCoord = vec2(x, -y);\n"
"}";
const char* kScreenFragmentShader =
"#version 330 core\n"
"out vec4 fColor;\n"
"in vec2 texCoord;\n"
"uniform sampler2D texture;\n"
"void main() {\n"
"\tfColor = texture2D(texture, texCoord);\n"
"}";
const char* kUpdateRectVertexShader =
"#version 330 core\n"
"layout (location = 0) in vec2 pos;\n"
"layout (location = 1) in vec3 color;\n"
"out vec4 vColor;\n"
"uniform mat4 transform;\n"
"void main() {\n"
"\tgl_Position = transform * vec4(pos, 0.0f, 1.0f);\n"
"\tvColor = vec4(color, 1.0f);\n"
"}";
const char* kUpdateRectFragmentShader =
"#version 330 core\n"
"out vec4 fColor;\n"
"in vec4 vColor;\n"
"void main() {\n"
"\tfColor = vColor;\n"
"}";
// clang-format off
constexpr float kLineVertices[] = {
// pos // color
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, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f, 0.0f
};
// clang-format on
using mat4x4_t = float[16];
void mat4x4_identity(mat4x4_t& matrix) {
// row 0
matrix[0] = 1.0f;
matrix[1] = 0.0f;
matrix[2] = 0.0f;
matrix[3] = 0.0f;
// row 1
matrix[4] = 0.0f;
matrix[5] = 1.0f;
matrix[6] = 0.0f;
matrix[7] = 0.0f;
// row 2
matrix[8] = 0.0f;
matrix[9] = 0.0f;
matrix[10] = 1.0f;
matrix[11] = 0.0f;
// row 3
matrix[12] = 0.0f;
matrix[13] = 0.0f;
matrix[14] = 0.0f;
matrix[15] = 1.0f;
}
void mat4x4_rotate(mat4x4_t& matrix, float angle, float x, float y, float z) {
float c, s, t;
float length, theta;
// degrees to radians
theta = angle * (M_PI / 180.0f);
// normalize
length = sqrtf(x * x + y * y + z * z);
// too close to 0, can't make normalized vector
if (length < 0.0001f) {
return;
}
x /= length;
y /= length;
z /= length;
c = cosf(theta);
s = sinf(theta);
t = 1.0f - c;
// row 0
matrix[0] = t * x * x + c;
matrix[1] = t * x * y - s * z;
matrix[2] = t * x * z + s * y;
matrix[3] = 0.0f;
// row 1
matrix[4] = t * y * x + s * z;
matrix[5] = t * y * y + c;
matrix[6] = t * y * z - s * x;
matrix[7] = 0.0f;
// row 2
matrix[8] = t * x * z - s * y;
matrix[9] = t * y * z + s * x;
matrix[10] = t * z * z + c;
matrix[11] = 0.0f;
// row 3
matrix[12] = 0.0f;
matrix[13] = 0.0f;
matrix[14] = 0.0f;
matrix[15] = 1.0f;
}
void mat4x4_ortho(mat4x4_t& matrix,
float left,
float right,
float bottom,
float top,
float near,
float far) {
// row 0
matrix[0] = 2.0f / (right - left);
matrix[1] = 0.0f;
matrix[2] = 0.0f;
matrix[3] = 0.0f;
// row 1
matrix[4] = 0.0f;
matrix[5] = 2.0f / (top - bottom);
matrix[6] = 0.0f;
matrix[7] = 0.0f;
// row 2
matrix[8] = 0.0f;
matrix[9] = 0.0f;
matrix[10] = -2.0f / (far - near);
matrix[11] = 0.0f;
// row 3
matrix[12] = -(right + left) / (right - left);
matrix[13] = -(top + bottom) / (top - bottom);
matrix[14] = -(far + near) / (far - near);
matrix[15] = 1.0f;
}
void mat4x4_multiply(mat4x4_t& c, const mat4x4_t& a, const mat4x4_t& b) {
// row 0
c[0] = a[0] * b[0] + a[1] * b[4] + a[2] * b[8];
c[1] = a[0] * b[1] + a[1] * b[5] + a[2] * b[9];
c[2] = a[0] * b[2] + a[1] * b[6] + a[2] * b[10];
c[3] = a[0] * b[3] + a[1] * b[7] + a[2] * b[11] + a[3];
// row 1
c[4] = a[4] * b[0] + a[5] * b[4] + a[6] * b[8];
c[5] = a[4] * b[1] + a[5] * b[5] + a[6] * b[9];
c[6] = a[4] * b[2] + a[5] * b[6] + a[6] * b[10];
c[7] = a[4] * b[3] + a[5] * b[7] + a[6] * b[11] + a[7];
// row 2
c[8] = a[8] * b[0] + a[9] * b[4] + a[10] * b[8];
c[9] = a[8] * b[1] + a[9] * b[5] + a[10] * b[9];
c[10] = a[8] * b[2] + a[9] * b[6] + a[10] * b[10];
c[11] = a[8] * b[3] + a[9] * b[7] + a[10] * b[11] + a[11];
// row 3
c[12] = 0.0f;
c[13] = 0.0f;
c[14] = 0.0f;
c[15] = 1.0f;
}
} // namespace
#endif // USE_SHADERS
OsrRenderer::OsrRenderer(const OsrRendererSettings& settings)
: settings_(settings)
#if USE_SHADERS
,
line_vertices_(kLineVertices, kLineVertices + std::size(kLineVertices))
#endif
{
}
OsrRenderer::~OsrRenderer() {
Cleanup();
}
void OsrRenderer::Initialize() {
if (initialized_) {
return;
}
glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
VERIFY_NO_ERROR;
if (IsTransparent()) {
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
VERIFY_NO_ERROR;
} else {
glClearColor(float(CefColorGetR(settings_.background_color)) / 255.0f,
float(CefColorGetG(settings_.background_color)) / 255.0f,
float(CefColorGetB(settings_.background_color)) / 255.0f,
1.0f);
VERIFY_NO_ERROR;
}
#if USE_SHADERS
glGenVertexArrays(1, &vao_id_);
VERIFY_NO_ERROR;
glGenBuffers(1, &vbo_id_);
VERIFY_NO_ERROR;
glBindVertexArray(vao_id_);
VERIFY_NO_ERROR;
glBindBuffer(GL_ARRAY_BUFFER, vbo_id_);
VERIFY_NO_ERROR;
glBufferData(GL_ARRAY_BUFFER, line_vertices_.size() * sizeof(float), nullptr,
GL_STATIC_DRAW);
VERIFY_NO_ERROR;
int success;
unsigned int vertex_shader_id;
unsigned int fragment_shader_id;
char infoLog[512];
// create & compile screen vertex shader program
vertex_shader_id = glCreateShader(GL_VERTEX_SHADER);
VERIFY_NO_ERROR;
glShaderSource(vertex_shader_id, 1, &kScreenVertexShader, NULL);
VERIFY_NO_ERROR;
glCompileShader(vertex_shader_id);
VERIFY_NO_ERROR;
glGetShaderiv(vertex_shader_id, GL_COMPILE_STATUS, &success);
VERIFY_NO_ERROR;
if (!success) {
glGetShaderInfoLog(vertex_shader_id, 512, NULL, infoLog);
VERIFY_NO_ERROR;
LOG(ERROR) << "Vertex shader compile error: " << infoLog;
}
// create & compile screen fragment shader program
fragment_shader_id = glCreateShader(GL_FRAGMENT_SHADER);
VERIFY_NO_ERROR;
glShaderSource(fragment_shader_id, 1, &kScreenFragmentShader, NULL);
VERIFY_NO_ERROR;
glCompileShader(fragment_shader_id);
VERIFY_NO_ERROR;
glGetShaderiv(fragment_shader_id, GL_COMPILE_STATUS, &success);
VERIFY_NO_ERROR;
if (!success) {
glGetShaderInfoLog(fragment_shader_id, 512, NULL, infoLog);
VERIFY_NO_ERROR;
LOG(ERROR) << "Fragment shader compile error: " << infoLog;
}
// create final shader program
screen_shader_program_id_ = glCreateProgram();
VERIFY_NO_ERROR;
glAttachShader(screen_shader_program_id_, vertex_shader_id);
VERIFY_NO_ERROR;
glAttachShader(screen_shader_program_id_, fragment_shader_id);
VERIFY_NO_ERROR;
glLinkProgram(screen_shader_program_id_);
VERIFY_NO_ERROR;
glGetProgramiv(screen_shader_program_id_, GL_LINK_STATUS, &success);
VERIFY_NO_ERROR;
if (!success) {
glGetProgramInfoLog(screen_shader_program_id_, 512, NULL, infoLog);
VERIFY_NO_ERROR;
LOG(ERROR) << "Shader program link error: " << infoLog;
}
// delete the shader's as they're linked into our program now
glDeleteShader(vertex_shader_id);
VERIFY_NO_ERROR;
glDeleteShader(fragment_shader_id);
VERIFY_NO_ERROR;
// create & compile update rect vertex shader program
vertex_shader_id = glCreateShader(GL_VERTEX_SHADER);
VERIFY_NO_ERROR;
glShaderSource(vertex_shader_id, 1, &kUpdateRectVertexShader, NULL);
VERIFY_NO_ERROR;
glCompileShader(vertex_shader_id);
VERIFY_NO_ERROR;
glGetShaderiv(vertex_shader_id, GL_COMPILE_STATUS, &success);
VERIFY_NO_ERROR;
if (!success) {
glGetShaderInfoLog(vertex_shader_id, 512, NULL, infoLog);
VERIFY_NO_ERROR;
LOG(ERROR) << "Vertex shader compile error: " << infoLog;
}
// create & compile update rect fragment shader program
fragment_shader_id = glCreateShader(GL_FRAGMENT_SHADER);
VERIFY_NO_ERROR;
glShaderSource(fragment_shader_id, 1, &kUpdateRectFragmentShader, NULL);
VERIFY_NO_ERROR;
glCompileShader(fragment_shader_id);
VERIFY_NO_ERROR;
glGetShaderiv(fragment_shader_id, GL_COMPILE_STATUS, &success);
VERIFY_NO_ERROR;
if (!success) {
glGetShaderInfoLog(fragment_shader_id, 512, NULL, infoLog);
VERIFY_NO_ERROR;
LOG(ERROR) << "Fragment shader compile error: " << infoLog;
}
// create final shader program
update_rect_shader_program_id_ = glCreateProgram();
VERIFY_NO_ERROR;
glAttachShader(update_rect_shader_program_id_, vertex_shader_id);
VERIFY_NO_ERROR;
glAttachShader(update_rect_shader_program_id_, fragment_shader_id);
VERIFY_NO_ERROR;
glLinkProgram(update_rect_shader_program_id_);
VERIFY_NO_ERROR;
glGetProgramiv(update_rect_shader_program_id_, GL_LINK_STATUS, &success);
VERIFY_NO_ERROR;
if (!success) {
glGetProgramInfoLog(update_rect_shader_program_id_, 512, NULL, infoLog);
VERIFY_NO_ERROR;
LOG(ERROR) << "Shader program link error: " << infoLog;
}
// delete the shader's as they're linked into our program now
glDeleteShader(vertex_shader_id);
VERIFY_NO_ERROR;
glDeleteShader(fragment_shader_id);
VERIFY_NO_ERROR;
#endif // USE_SHADERS
// Necessary for non-power-of-2 textures to render correctly.
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
VERIFY_NO_ERROR;
// Create the texture.
glGenTextures(1, &texture_id_);
VERIFY_NO_ERROR;
DCHECK_NE(texture_id_, 0U);
VERIFY_NO_ERROR;
glBindTexture(GL_TEXTURE_2D, texture_id_);
VERIFY_NO_ERROR;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
VERIFY_NO_ERROR;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
VERIFY_NO_ERROR;
#if USE_SHADERS
glUseProgram(screen_shader_program_id_);
VERIFY_NO_ERROR;
glUniform1i(glGetUniformLocation(screen_shader_program_id_, "texture"), 0);
VERIFY_NO_ERROR;
#else
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
VERIFY_NO_ERROR;
#endif
initialized_ = true;
}
void OsrRenderer::Cleanup() {
if (texture_id_ != 0) {
glDeleteTextures(1, &texture_id_);
}
#if USE_SHADERS
if (vao_id_ != 0) {
glDeleteVertexArrays(1, &vao_id_);
}
if (screen_shader_program_id_ != 0) {
glDeleteProgram(screen_shader_program_id_);
}
if (update_rect_shader_program_id_ != 0) {
glDeleteProgram(screen_shader_program_id_);
}
#endif
}
void OsrRenderer::Render() {
if (view_width_ == 0 || view_height_ == 0) {
return;
}
DCHECK(initialized_);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
VERIFY_NO_ERROR;
// Match GL units to screen coordinates.
glViewport(0, 0, view_width_, view_height_);
VERIFY_NO_ERROR;
#if USE_SHADERS
mat4x4_t transformation;
mat4x4_t rotX, rotY;
mat4x4_identity(transformation);
mat4x4_identity(rotX);
mat4x4_identity(rotY);
// Rotate the view based on the mouse spin.
if (spin_x_ != 0) {
mat4x4_rotate(rotX, -spin_x_, 1.0f, 0.0f, 0.0f);
}
if (spin_y_ != 0) {
mat4x4_rotate(rotY, -spin_y_, 0.0f, 1.0f, 0.0f);
}
mat4x4_multiply(transformation, rotX, rotY);
if (IsTransparent()) {
// Alpha blending style. Texture values have premultiplied alpha.
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
VERIFY_NO_ERROR;
// Enable alpha blending.
glEnable(GL_BLEND);
VERIFY_NO_ERROR;
}
glActiveTexture(GL_TEXTURE0);
VERIFY_NO_ERROR;
glBindTexture(GL_TEXTURE_2D, texture_id_);
VERIFY_NO_ERROR;
glUseProgram(screen_shader_program_id_);
VERIFY_NO_ERROR;
glUniformMatrix4fv(
glGetUniformLocation(screen_shader_program_id_, "transform"), 1, GL_FALSE,
transformation);
VERIFY_NO_ERROR;
glDrawArrays(GL_TRIANGLES, 0, 6);
VERIFY_NO_ERROR;
if (IsTransparent()) {
// Disable alpha blending.
glDisable(GL_BLEND);
VERIFY_NO_ERROR;
}
// Draw a rectangle around the update region.
if (settings_.show_update_rect && !update_rect_.IsEmpty()) {
mat4x4_t projection;
int left = update_rect_.x;
int right = update_rect_.x + update_rect_.width;
int top = update_rect_.y;
int bottom = update_rect_.y + update_rect_.height;
float* vertices = line_vertices_.data();
#if defined(OS_LINUX)
// Shrink the box so that top & right sides are drawn.
top += 1;
right -= 1;
#else
// Shrink the box so that left & bottom sides are drawn.
left += 1;
bottom -= 1;
#endif
mat4x4_ortho(projection, 0.0f, view_width_, view_height_, 0.0f, 0.0f, 1.0f);
// v0
vertices[0] = left;
vertices[1] = top;
// v1
vertices[5] = right;
vertices[6] = top;
// v2
vertices[10] = right;
vertices[11] = bottom;
// v3
vertices[15] = left;
vertices[16] = bottom;
// v4
vertices[20] = left;
vertices[21] = top;
void* ptr = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
VERIFY_NO_ERROR;
memcpy(ptr, line_vertices_.data(), line_vertices_.size() * sizeof(float));
glUnmapBuffer(GL_ARRAY_BUFFER);
VERIFY_NO_ERROR;
glLineWidth(1.0f);
VERIFY_NO_ERROR;
glUseProgram(update_rect_shader_program_id_);
VERIFY_NO_ERROR;
glUniformMatrix4fv(
glGetUniformLocation(update_rect_shader_program_id_, "transform"), 1,
GL_FALSE, projection);
VERIFY_NO_ERROR;
glEnableVertexAttribArray(0);
VERIFY_NO_ERROR;
glEnableVertexAttribArray(1);
VERIFY_NO_ERROR;
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float),
(void*)0);
VERIFY_NO_ERROR;
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float),
(void*)(2 * sizeof(float)));
VERIFY_NO_ERROR;
glDrawArrays(GL_LINE_LOOP, 0, 5);
VERIFY_NO_ERROR;
glDisableVertexAttribArray(0);
VERIFY_NO_ERROR;
glDisableVertexAttribArray(1);
VERIFY_NO_ERROR;
}
#else // !USE_SHADERS
struct {
float tu, tv;
float x, y, z;
} static vertices[] = {{0.0f, 1.0f, -1.0f, -1.0f, 0.0f},
{1.0f, 1.0f, 1.0f, -1.0f, 0.0f},
{1.0f, 0.0f, 1.0f, 1.0f, 0.0f},
{0.0f, 0.0f, -1.0f, 1.0f, 0.0f}};
glMatrixMode(GL_MODELVIEW);
VERIFY_NO_ERROR;
glLoadIdentity();
VERIFY_NO_ERROR;
glMatrixMode(GL_PROJECTION);
VERIFY_NO_ERROR;
glLoadIdentity();
VERIFY_NO_ERROR;
// Draw the background gradient.
glPushAttrib(GL_ALL_ATTRIB_BITS);
VERIFY_NO_ERROR;
// Don't check for errors until glEnd().
glBegin(GL_QUADS);
glColor4f(1.0, 0.0, 0.0, 1.0); // red
glVertex2f(-1.0, -1.0);
glVertex2f(1.0, -1.0);
glColor4f(0.0, 0.0, 1.0, 1.0); // blue
glVertex2f(1.0, 1.0);
glVertex2f(-1.0, 1.0);
glEnd();
VERIFY_NO_ERROR;
glPopAttrib();
VERIFY_NO_ERROR;
// Rotate the view based on the mouse spin.
if (spin_x_ != 0) {
glRotatef(-spin_x_, 1.0f, 0.0f, 0.0f);
VERIFY_NO_ERROR;
}
if (spin_y_ != 0) {
glRotatef(-spin_y_, 0.0f, 1.0f, 0.0f);
VERIFY_NO_ERROR;
}
if (IsTransparent()) {
// Alpha blending style. Texture values have premultiplied alpha.
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
VERIFY_NO_ERROR;
// Enable alpha blending.
glEnable(GL_BLEND);
VERIFY_NO_ERROR;
}
// Enable 2D textures.
glEnable(GL_TEXTURE_2D);
VERIFY_NO_ERROR;
// Draw the facets with the texture.
DCHECK_NE(texture_id_, 0U);
VERIFY_NO_ERROR;
glBindTexture(GL_TEXTURE_2D, texture_id_);
VERIFY_NO_ERROR;
glInterleavedArrays(GL_T2F_V3F, 0, vertices);
VERIFY_NO_ERROR;
glDrawArrays(GL_QUADS, 0, 4);
VERIFY_NO_ERROR;
// Disable 2D textures.
glDisable(GL_TEXTURE_2D);
VERIFY_NO_ERROR;
if (IsTransparent()) {
// Disable alpha blending.
glDisable(GL_BLEND);
VERIFY_NO_ERROR;
}
// Draw a rectangle around the update region.
if (settings_.show_update_rect && !update_rect_.IsEmpty()) {
int left = update_rect_.x;
int right = update_rect_.x + update_rect_.width;
int top = update_rect_.y;
int bottom = update_rect_.y + update_rect_.height;
#if defined(OS_LINUX)
// Shrink the box so that top & right sides are drawn.
top += 1;
right -= 1;
#else
// Shrink the box so that left & bottom sides are drawn.
left += 1;
bottom -= 1;
#endif
glPushAttrib(GL_ALL_ATTRIB_BITS);
VERIFY_NO_ERROR
glMatrixMode(GL_PROJECTION);
VERIFY_NO_ERROR;
glPushMatrix();
VERIFY_NO_ERROR;
glLoadIdentity();
VERIFY_NO_ERROR;
glOrtho(0, view_width_, view_height_, 0, 0, 1);
VERIFY_NO_ERROR;
glLineWidth(1);
VERIFY_NO_ERROR;
glColor3f(1.0f, 0.0f, 0.0f);
VERIFY_NO_ERROR;
// Don't check for errors until glEnd().
glBegin(GL_LINE_STRIP);
glVertex2i(left, top);
glVertex2i(right, top);
glVertex2i(right, bottom);
glVertex2i(left, bottom);
glVertex2i(left, top);
glEnd();
VERIFY_NO_ERROR;
glPopMatrix();
VERIFY_NO_ERROR;
glPopAttrib();
VERIFY_NO_ERROR;
}
#endif // !USE_SHADERS
}
void OsrRenderer::OnPopupShow(CefRefPtr<CefBrowser> browser, bool show) {
if (!show) {
// Clear the popup rectangle.
ClearPopupRects();
}
}
void OsrRenderer::OnPopupSize(CefRefPtr<CefBrowser> browser,
const CefRect& rect) {
if (rect.width <= 0 || rect.height <= 0) {
return;
}
original_popup_rect_ = rect;
popup_rect_ = GetPopupRectInWebView(original_popup_rect_);
}
CefRect OsrRenderer::GetPopupRectInWebView(const CefRect& original_rect) {
CefRect rc(original_rect);
// if x or y are negative, move them to 0.
if (rc.x < 0) {
rc.x = 0;
}
if (rc.y < 0) {
rc.y = 0;
}
// if popup goes outside the view, try to reposition origin
if (rc.x + rc.width > view_width_) {
rc.x = view_width_ - rc.width;
}
if (rc.y + rc.height > view_height_) {
rc.y = view_height_ - rc.height;
}
// if x or y became negative, move them to 0 again.
if (rc.x < 0) {
rc.x = 0;
}
if (rc.y < 0) {
rc.y = 0;
}
return rc;
}
void OsrRenderer::ClearPopupRects() {
popup_rect_.Set(0, 0, 0, 0);
original_popup_rect_.Set(0, 0, 0, 0);
}
void OsrRenderer::OnAcceleratedPaint(
CefRefPtr<CefBrowser> browser,
CefRenderHandler::PaintElementType type,
const CefRenderHandler::RectList& dirtyRects,
unsigned int io_surface_tex,
int width,
int height) {
if (!initialized_) {
Initialize();
}
#if !defined(OS_WIN)
if (width != view_width_ || height != view_height_) {
// Width or height has changed, so proceed to update the texture
view_width_ = width;
view_height_ = height;
// Rebind texture_id as the active texture
glBindTexture(GL_TEXTURE_2D, texture_id_);
VERIFY_NO_ERROR;
// Allocate a new storage for texture_id with the new dimensions
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_BGRA,
GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
VERIFY_NO_ERROR;
}
if (IsTransparent()) {
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
VERIFY_NO_ERROR;
// Enable alpha blending.
glEnable(GL_BLEND);
VERIFY_NO_ERROR;
}
GLuint framebuffer;
glGenFramebuffers(1, &framebuffer);
VERIFY_NO_ERROR;
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
VERIFY_NO_ERROR;
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
texture_id_, 0);
VERIFY_NO_ERROR;
// Check framebuffer status
DCHECK(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
glPushAttrib(GL_ALL_ATTRIB_BITS);
VERIFY_NO_ERROR;
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
VERIFY_NO_ERROR;
// Setup OpenGL states
glViewport(0, 0, width, height);
VERIFY_NO_ERROR;
// Bind the GL_TEXTURE_RECTANGLE_ARB texture
glActiveTexture(GL_TEXTURE0);
VERIFY_NO_ERROR;
glClientActiveTexture(GL_TEXTURE0);
VERIFY_NO_ERROR;
glMatrixMode(GL_TEXTURE);
VERIFY_NO_ERROR;
glPushMatrix();
VERIFY_NO_ERROR;
glLoadIdentity();
VERIFY_NO_ERROR;
glMatrixMode(GL_PROJECTION);
VERIFY_NO_ERROR;
glPushMatrix();
VERIFY_NO_ERROR;
glLoadIdentity();
VERIFY_NO_ERROR;
glOrtho(0, width, 0, height, -1, 1);
VERIFY_NO_ERROR;
glMatrixMode(GL_MODELVIEW);
VERIFY_NO_ERROR;
glPushMatrix();
VERIFY_NO_ERROR;
glLoadIdentity();
VERIFY_NO_ERROR;
// rectangleTexture is the GL_TEXTURE_RECTANGLE_ARB
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, io_surface_tex);
VERIFY_NO_ERROR;
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
VERIFY_NO_ERROR;
glColor4f(1.0, 1.0, 1.0, 1.0);
VERIFY_NO_ERROR;
bool isFlipped = false;
GLfloat tex_coords[8];
GLfloat texOriginX = 0;
GLfloat texOriginY = 0;
GLfloat texExtentX = width;
GLfloat texExtentY = height;
// X
tex_coords[0] = texOriginX;
tex_coords[2] = texOriginX;
tex_coords[4] = texExtentX;
tex_coords[6] = texExtentX;
// Y
if (!isFlipped) {
tex_coords[1] = texOriginY;
tex_coords[3] = texExtentY;
tex_coords[5] = texExtentY;
tex_coords[7] = texOriginY;
} else {
tex_coords[1] = texExtentY;
tex_coords[3] = texOriginY;
tex_coords[5] = texOriginY;
tex_coords[7] = texExtentY;
}
GLfloat verts[] = {
0.0f, 0.0f, 0.0f, (float)height,
(float)width, (float)height, (float)width, 0.0f,
};
// Ought to cache the GL_ARRAY_BUFFER_BINDING,
// GL_ELEMENT_ARRAY_BUFFER_BINDING, set buffer to 0, and reset
GLint arrayBuffer, elementArrayBuffer;
glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &elementArrayBuffer);
VERIFY_NO_ERROR;
glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &arrayBuffer);
VERIFY_NO_ERROR;
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
VERIFY_NO_ERROR;
glBindBuffer(GL_ARRAY_BUFFER, 0);
VERIFY_NO_ERROR;
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
VERIFY_NO_ERROR;
glTexCoordPointer(2, GL_FLOAT, 0, tex_coords);
VERIFY_NO_ERROR;
glEnableClientState(GL_VERTEX_ARRAY);
VERIFY_NO_ERROR;
glVertexPointer(2, GL_FLOAT, 0, verts);
VERIFY_NO_ERROR;
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
VERIFY_NO_ERROR;
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementArrayBuffer);
VERIFY_NO_ERROR;
glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer);
VERIFY_NO_ERROR;
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
VERIFY_NO_ERROR;
// Restore OpenGL states
glMatrixMode(GL_MODELVIEW);
VERIFY_NO_ERROR;
glPopMatrix();
VERIFY_NO_ERROR;
glMatrixMode(GL_PROJECTION);
VERIFY_NO_ERROR;
glPopMatrix();
VERIFY_NO_ERROR;
glMatrixMode(GL_TEXTURE);
VERIFY_NO_ERROR;
glPopMatrix();
VERIFY_NO_ERROR;
glPopClientAttrib();
VERIFY_NO_ERROR;
glPopAttrib();
VERIFY_NO_ERROR;
if (IsTransparent()) {
// Enable alpha blending.
glDisable(GL_BLEND);
VERIFY_NO_ERROR;
}
// 0 unbinds the FBO, reverting to the default buffer
glBindFramebuffer(GL_FRAMEBUFFER, 0);
VERIFY_NO_ERROR;
glDeleteFramebuffers(1, &framebuffer);
VERIFY_NO_ERROR;
// Delete the rectangle texture
glDeleteTextures(1, &io_surface_tex);
VERIFY_NO_ERROR;
glDisable(GL_TEXTURE_RECTANGLE_ARB);
VERIFY_NO_ERROR;
#endif // !defined(OS_WIN)
}
void OsrRenderer::OnPaint(CefRefPtr<CefBrowser> browser,
CefRenderHandler::PaintElementType type,
const CefRenderHandler::RectList& dirtyRects,
const void* buffer,
int width,
int height) {
if (!initialized_) {
Initialize();
}
if (IsTransparent()) {
// Enable alpha blending.
glEnable(GL_BLEND);
VERIFY_NO_ERROR;
}
#if !USE_SHADERS
// Enable 2D textures.
glEnable(GL_TEXTURE_2D);
VERIFY_NO_ERROR;
#endif
DCHECK_NE(texture_id_, 0U);
glBindTexture(GL_TEXTURE_2D, texture_id_);
VERIFY_NO_ERROR;
if (type == PET_VIEW) {
int old_width = view_width_;
int old_height = view_height_;
view_width_ = width;
view_height_ = height;
if (settings_.show_update_rect) {
update_rect_ = dirtyRects[0];
}
glPixelStorei(GL_UNPACK_ROW_LENGTH, view_width_);
VERIFY_NO_ERROR;
if (old_width != view_width_ || old_height != view_height_ ||
(dirtyRects.size() == 1 &&
dirtyRects[0] == CefRect(0, 0, view_width_, view_height_))) {
// Update/resize the whole texture.
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
VERIFY_NO_ERROR;
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
VERIFY_NO_ERROR;
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, view_width_, view_height_, 0,
GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, buffer);
VERIFY_NO_ERROR;
} else {
// Update just the dirty rectangles.
CefRenderHandler::RectList::const_iterator i = dirtyRects.begin();
for (; i != dirtyRects.end(); ++i) {
const CefRect& rect = *i;
DCHECK(rect.x + rect.width <= view_width_);
DCHECK(rect.y + rect.height <= view_height_);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, rect.x);
VERIFY_NO_ERROR;
glPixelStorei(GL_UNPACK_SKIP_ROWS, rect.y);
VERIFY_NO_ERROR;
glTexSubImage2D(GL_TEXTURE_2D, 0, rect.x, rect.y, rect.width,
rect.height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
buffer);
VERIFY_NO_ERROR;
}
}
} else if (type == PET_POPUP && popup_rect_.width > 0 &&
popup_rect_.height > 0) {
int skip_pixels = 0, x = popup_rect_.x;
int skip_rows = 0, y = popup_rect_.y;
int w = width;
int h = height;
// Adjust the popup to fit inside the view.
if (x < 0) {
skip_pixels = -x;
x = 0;
}
if (y < 0) {
skip_rows = -y;
y = 0;
}
if (x + w > view_width_) {
w -= x + w - view_width_;
}
if (y + h > view_height_) {
h -= y + h - view_height_;
}
// Update the popup rectangle.
glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
VERIFY_NO_ERROR;
glPixelStorei(GL_UNPACK_SKIP_PIXELS, skip_pixels);
VERIFY_NO_ERROR;
glPixelStorei(GL_UNPACK_SKIP_ROWS, skip_rows);
VERIFY_NO_ERROR;
glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h, GL_BGRA,
GL_UNSIGNED_INT_8_8_8_8_REV, buffer);
VERIFY_NO_ERROR;
}
#if !USE_SHADERS
// Disable 2D textures.
glDisable(GL_TEXTURE_2D);
VERIFY_NO_ERROR;
#endif
if (IsTransparent()) {
// Disable alpha blending.
glDisable(GL_BLEND);
VERIFY_NO_ERROR;
}
}
void OsrRenderer::SetSpin(float spinX, float spinY) {
spin_x_ = spinX;
spin_y_ = spinY;
}
void OsrRenderer::IncrementSpin(float spinDX, float spinDY) {
spin_x_ -= spinDX;
spin_y_ -= spinDY;
}
} // namespace client
#if defined(__clang__)
// End disable NSOpenGL deprecation warnings.
#pragma clang diagnostic pop
#endif
Reference in New Issue View Git Blame Copy Permalink