diff options
Diffstat (limited to 'cc')
40 files changed, 1654 insertions, 1737 deletions
diff --git a/cc/BUILD.gn b/cc/BUILD.gn index 8581541..bf77c0e 100644 --- a/cc/BUILD.gn +++ b/cc/BUILD.gn @@ -253,6 +253,8 @@ component("cc") { "output/delegating_renderer.h", "output/direct_renderer.cc", "output/direct_renderer.h", + "output/dynamic_geometry_binding.cc", + "output/dynamic_geometry_binding.h", "output/filter_operation.cc", "output/filter_operation.h", "output/filter_operations.cc", @@ -293,6 +295,8 @@ component("cc") { "output/software_output_device.h", "output/software_renderer.cc", "output/software_renderer.h", + "output/static_geometry_binding.cc", + "output/static_geometry_binding.h", "output/viewport_selection_bound.cc", "output/viewport_selection_bound.h", "output/vsync_parameter_observer.h", @@ -504,8 +508,6 @@ component("cc") { "trees/damage_tracker.h", "trees/draw_property_utils.cc", "trees/draw_property_utils.h", - "trees/layer_sorter.cc", - "trees/layer_sorter.h", "trees/layer_tree_host.cc", "trees/layer_tree_host.h", "trees/layer_tree_host_client.h", @@ -830,7 +832,6 @@ test("cc_unittests") { "test/test_web_graphics_context_3d_unittest.cc", "trees/blocking_task_runner_unittest.cc", "trees/damage_tracker_unittest.cc", - "trees/layer_sorter_unittest.cc", "trees/layer_tree_host_common_unittest.cc", "trees/layer_tree_host_impl_unittest.cc", "trees/layer_tree_host_pixeltest_blending.cc", @@ -279,6 +279,8 @@ 'output/delegating_renderer.h', 'output/direct_renderer.cc', 'output/direct_renderer.h', + 'output/dynamic_geometry_binding.cc', + 'output/dynamic_geometry_binding.h', 'output/filter_operation.cc', 'output/filter_operation.h', 'output/filter_operations.cc', @@ -319,6 +321,8 @@ 'output/software_output_device.h', 'output/software_renderer.cc', 'output/software_renderer.h', + 'output/static_geometry_binding.cc', + 'output/static_geometry_binding.h', 'output/viewport_selection_bound.cc', 'output/viewport_selection_bound.h', 'output/vsync_parameter_observer.h', @@ -531,8 +535,6 @@ 'trees/damage_tracker.h', 'trees/draw_property_utils.cc', 'trees/draw_property_utils.h', - 'trees/layer_sorter.cc', - 'trees/layer_sorter.h', 'trees/layer_tree_host.cc', 'trees/layer_tree_host.h', 'trees/layer_tree_host_client.h', diff --git a/cc/cc_tests.gyp b/cc/cc_tests.gyp index fd5de02..bafd747 100644 --- a/cc/cc_tests.gyp +++ b/cc/cc_tests.gyp @@ -106,7 +106,6 @@ 'test/test_web_graphics_context_3d_unittest.cc', 'trees/blocking_task_runner_unittest.cc', 'trees/damage_tracker_unittest.cc', - 'trees/layer_sorter_unittest.cc', 'trees/layer_tree_host_common_unittest.cc', 'trees/layer_tree_host_impl_unittest.cc', 'trees/layer_tree_host_pixeltest_blending.cc', diff --git a/cc/output/bsp_tree.cc b/cc/output/bsp_tree.cc index f2318ce..4eb87cb 100644 --- a/cc/output/bsp_tree.cc +++ b/cc/output/bsp_tree.cc @@ -62,10 +62,9 @@ void BspTree::BuildTree(BspNode* node, scoped_ptr<DrawPolygon> polygon; scoped_ptr<DrawPolygon> new_front; scoped_ptr<DrawPolygon> new_back; - bool split_result = false; // Time to split this geometry, *it needs to be split by node_data. polygon = polygon_list->take_front(); - split_result = + bool split_result = polygon->Split(*(node->node_data), &new_front, &new_back); DCHECK(split_result); if (!split_result) { diff --git a/cc/output/bsp_walk_action.cc b/cc/output/bsp_walk_action.cc index da5ada5..9ffc299 100644 --- a/cc/output/bsp_walk_action.cc +++ b/cc/output/bsp_walk_action.cc @@ -9,15 +9,37 @@ #include "base/memory/scoped_ptr.h" #include "cc/output/direct_renderer.h" #include "cc/quads/draw_polygon.h" +#include "cc/quads/draw_quad.h" namespace cc { -void BspWalkActionToVector::operator()(DrawPolygon* item) { - list_->push_back(item); +BspWalkActionDrawPolygon::BspWalkActionDrawPolygon( + DirectRenderer* renderer, + DirectRenderer::DrawingFrame* frame, + const gfx::Rect& render_pass_scissor, + bool using_scissor_as_optimization) + : renderer_(renderer), + frame_(frame), + render_pass_scissor_(render_pass_scissor), + using_scissor_as_optimization_(using_scissor_as_optimization) { +} + +void BspWalkActionDrawPolygon::operator()(DrawPolygon* item) { + gfx::Transform inverse_transform; + bool invertible = + item->original_ref()->quadTransform().GetInverse(&inverse_transform); + DCHECK(invertible); + item->TransformToLayerSpace(inverse_transform); + renderer_->DoDrawPolygon(*item, frame_, render_pass_scissor_, + using_scissor_as_optimization_); } BspWalkActionToVector::BspWalkActionToVector(std::vector<DrawPolygon*>* in_list) : list_(in_list) { } +void BspWalkActionToVector::operator()(DrawPolygon* item) { + list_->push_back(item); +} + } // namespace cc diff --git a/cc/output/bsp_walk_action.h b/cc/output/bsp_walk_action.h index ac8fa41..a89d8ea 100644 --- a/cc/output/bsp_walk_action.h +++ b/cc/output/bsp_walk_action.h @@ -20,6 +20,22 @@ class CC_EXPORT BspWalkAction { // The BspTree class takes ownership of all the DrawPolygons returned in list_ // so the BspTree must be preserved while elements in that vector are in use. +class CC_EXPORT BspWalkActionDrawPolygon : public BspWalkAction { + public: + void operator()(DrawPolygon* item) override; + + BspWalkActionDrawPolygon(DirectRenderer* renderer, + DirectRenderer::DrawingFrame* frame, + const gfx::Rect& render_pass_scissor, + bool using_scissor_as_optimization); + + private: + DirectRenderer* renderer_; + DirectRenderer::DrawingFrame* frame_; + const gfx::Rect& render_pass_scissor_; + bool using_scissor_as_optimization_; +}; + class CC_EXPORT BspWalkActionToVector : public BspWalkAction { public: explicit BspWalkActionToVector(std::vector<DrawPolygon*>* in_list); diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc index 5867fce..0ae4179 100644 --- a/cc/output/direct_renderer.cc +++ b/cc/output/direct_renderer.cc @@ -12,6 +12,8 @@ #include "base/metrics/histogram.h" #include "base/trace_event/trace_event.h" #include "cc/base/math_util.h" +#include "cc/output/bsp_tree.h" +#include "cc/output/bsp_walk_action.h" #include "cc/output/copy_output_request.h" #include "cc/quads/draw_quad.h" #include "ui/gfx/geometry/rect_conversions.h" @@ -299,22 +301,27 @@ void DirectRenderer::SetScissorStateForQuad(const DrawingFrame* frame, EnsureScissorTestDisabled(); } +bool DirectRenderer::ShouldSkipQuad(const DrawQuad& quad, + const gfx::Rect& render_pass_scissor) { + if (render_pass_scissor.IsEmpty()) + return true; + + if (quad.isClipped()) { + gfx::Rect r = quad.clipRect(); + r.Intersect(render_pass_scissor); + return r.IsEmpty(); + } + + return false; +} + void DirectRenderer::SetScissorStateForQuadWithRenderPassScissor( const DrawingFrame* frame, const DrawQuad& quad, - const gfx::Rect& render_pass_scissor, - bool* should_skip_quad) { + const gfx::Rect& render_pass_scissor) { gfx::Rect quad_scissor_rect = render_pass_scissor; - if (quad.isClipped()) quad_scissor_rect.Intersect(quad.clipRect()); - - if (quad_scissor_rect.IsEmpty()) { - *should_skip_quad = true; - return; - } - - *should_skip_quad = false; SetScissorTestRectInDrawSpace(frame, quad_scissor_rect); } @@ -330,6 +337,46 @@ void DirectRenderer::SetScissorTestRectInDrawSpace( void DirectRenderer::FinishDrawingQuadList() {} +void DirectRenderer::DoDrawPolygon(const DrawPolygon& poly, + DrawingFrame* frame, + const gfx::Rect& render_pass_scissor, + bool using_scissor_as_optimization) { + if (using_scissor_as_optimization) { + SetScissorStateForQuadWithRenderPassScissor(frame, *poly.original_ref(), + render_pass_scissor); + } else { + SetScissorStateForQuad(frame, *poly.original_ref()); + } + + // If the poly has not been split, then it is just a normal DrawQuad, + // and we should save any extra processing that would have to be done. + if (!poly.is_split()) { + DoDrawQuad(frame, poly.original_ref(), NULL); + return; + } + + std::vector<gfx::QuadF> quads; + poly.ToQuads2D(&quads); + for (size_t i = 0; i < quads.size(); ++i) { + DoDrawQuad(frame, poly.original_ref(), &quads[i]); + } +} + +void DirectRenderer::FlushPolygons(ScopedPtrDeque<DrawPolygon>* poly_list, + DrawingFrame* frame, + const gfx::Rect& render_pass_scissor, + bool using_scissor_as_optimization) { + if (poly_list->empty()) { + return; + } + + BspTree bsp_tree(poly_list); + BspWalkActionDrawPolygon action_handler(this, frame, render_pass_scissor, + using_scissor_as_optimization); + bsp_tree.TraverseWithActionHandler(&action_handler); + DCHECK(poly_list->empty()); +} + void DirectRenderer::DrawRenderPass(DrawingFrame* frame, const RenderPass* render_pass) { TRACE_EVENT0("cc", "DirectRenderer::DrawRenderPass"); @@ -369,21 +416,49 @@ void DirectRenderer::DrawRenderPass(DrawingFrame* frame, } const QuadList& quad_list = render_pass->quad_list; + ScopedPtrDeque<DrawPolygon> poly_list; + + int next_polygon_id = 0; + int last_sorting_context_id = 0; for (auto it = quad_list.BackToFrontBegin(); it != quad_list.BackToFrontEnd(); ++it) { const DrawQuad& quad = **it; - bool should_skip_quad = false; + gfx::QuadF send_quad(quad.visible_rect); + + if (using_scissor_as_optimization && + ShouldSkipQuad(quad, render_pass_scissor)) { + continue; + } + + if (last_sorting_context_id != quad.shared_quad_state->sorting_context_id) { + last_sorting_context_id = quad.shared_quad_state->sorting_context_id; + FlushPolygons(&poly_list, frame, render_pass_scissor, + using_scissor_as_optimization); + } + + // This layer is in a 3D sorting context so we add it to the list of + // polygons to go into the BSP tree. + if (quad.shared_quad_state->sorting_context_id != 0) { + scoped_ptr<DrawPolygon> new_polygon(new DrawPolygon( + *it, quad.visible_rect, quad.quadTransform(), next_polygon_id++)); + if (new_polygon->points().size() > 2u) { + poly_list.push_back(new_polygon.Pass()); + } + continue; + } + // We are not in a 3d sorting context, so we should draw the quad normally. if (using_scissor_as_optimization) { - SetScissorStateForQuadWithRenderPassScissor( - frame, quad, render_pass_scissor, &should_skip_quad); + SetScissorStateForQuadWithRenderPassScissor(frame, quad, + render_pass_scissor); } else { SetScissorStateForQuad(frame, quad); } - if (!should_skip_quad) - DoDrawQuad(frame, &quad); + DoDrawQuad(frame, &quad, nullptr); } + FlushPolygons(&poly_list, frame, render_pass_scissor, + using_scissor_as_optimization); FinishDrawingQuadList(); } diff --git a/cc/output/direct_renderer.h b/cc/output/direct_renderer.h index e07cb93..3399491 100644 --- a/cc/output/direct_renderer.h +++ b/cc/output/direct_renderer.h @@ -9,13 +9,17 @@ #include "base/callback.h" #include "base/containers/scoped_ptr_hash_map.h" #include "cc/base/cc_export.h" +#include "cc/base/scoped_ptr_deque.h" #include "cc/output/overlay_processor.h" #include "cc/output/renderer.h" #include "cc/resources/resource_provider.h" #include "cc/resources/scoped_resource.h" +#include "cc/resources/task_graph_runner.h" +#include "ui/gfx/geometry/quad_f.h" namespace cc { +class DrawPolygon; class ResourceProvider; // This is the base class for code shared between the GL and software @@ -56,6 +60,10 @@ class CC_EXPORT DirectRenderer : public Renderer { }; void SetEnlargePassTextureAmountForTesting(const gfx::Vector2d& amount); + void DoDrawPolygon(const DrawPolygon& poly, + DrawingFrame* frame, + const gfx::Rect& render_pass_scissor, + bool using_scissor_as_optimization); protected: DirectRenderer(RendererClient* client, @@ -78,16 +86,21 @@ class CC_EXPORT DirectRenderer : public Renderer { gfx::Rect DeviceClipRectInWindowSpace(const DrawingFrame* frame) const; static gfx::Rect ComputeScissorRectForRenderPass(const DrawingFrame* frame); void SetScissorStateForQuad(const DrawingFrame* frame, const DrawQuad& quad); + bool ShouldSkipQuad(const DrawQuad& quad, + const gfx::Rect& render_pass_scissor); void SetScissorStateForQuadWithRenderPassScissor( const DrawingFrame* frame, const DrawQuad& quad, - const gfx::Rect& render_pass_scissor, - bool* should_skip_quad); + const gfx::Rect& render_pass_scissor); void SetScissorTestRectInDrawSpace(const DrawingFrame* frame, const gfx::Rect& draw_space_rect); static gfx::Size RenderPassTextureSize(const RenderPass* render_pass); + void FlushPolygons(ScopedPtrDeque<DrawPolygon>* poly_list, + DrawingFrame* frame, + const gfx::Rect& render_pass_scissor, + bool using_scissor_as_optimization); void DrawRenderPass(DrawingFrame* frame, const RenderPass* render_pass); bool UseRenderPass(DrawingFrame* frame, const RenderPass* render_pass); @@ -101,7 +114,12 @@ class CC_EXPORT DirectRenderer : public Renderer { bool draw_rect_covers_full_surface) = 0; virtual void ClearFramebuffer(DrawingFrame* frame, bool has_external_stencil_test) = 0; - virtual void DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) = 0; + // clip_region is a (possibly null) pointer to a quad in the same + // space as the quad. When non-null only the area of the quad that overlaps + // with clip_region will be drawn. + virtual void DoDrawQuad(DrawingFrame* frame, + const DrawQuad* quad, + const gfx::QuadF* clip_region) = 0; virtual void BeginDrawingFrame(DrawingFrame* frame) = 0; virtual void FinishDrawingFrame(DrawingFrame* frame) = 0; virtual void FinishDrawingQuadList(); diff --git a/cc/output/dynamic_geometry_binding.cc b/cc/output/dynamic_geometry_binding.cc new file mode 100644 index 0000000..9e25892 --- /dev/null +++ b/cc/output/dynamic_geometry_binding.cc @@ -0,0 +1,67 @@ +// Copyright 2015 The Chromium 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 "cc/output/dynamic_geometry_binding.h" + +#include "cc/output/gl_renderer.h" // For the GLC() macro. +#include "gpu/command_buffer/client/gles2_interface.h" +#include "ui/gfx/geometry/rect_f.h" + +namespace cc { + +DynamicGeometryBinding::DynamicGeometryBinding(gpu::gles2::GLES2Interface* gl) + : gl_(gl), quad_vertices_vbo_(0), quad_elements_vbo_(0) { + GeometryBindingQuad quads[1]; + GeometryBindingQuadIndex quad_indices[1]; + + static_assert(sizeof(GeometryBindingQuad) == 24 * sizeof(float), + "struct Quad should be densely packed"); + static_assert(sizeof(GeometryBindingQuadIndex) == 6 * sizeof(uint16_t), + "struct QuadIndex should be densely packed"); + + GLC(gl_, gl_->GenBuffers(1, &quad_vertices_vbo_)); + GLC(gl_, gl_->GenBuffers(1, &quad_elements_vbo_)); + + GLC(gl_, gl_->BindBuffer(GL_ARRAY_BUFFER, quad_vertices_vbo_)); + GLC(gl_, gl_->BufferData(GL_ARRAY_BUFFER, sizeof(GeometryBindingQuad) * 1, + quads, GL_DYNAMIC_DRAW)); + + GLC(gl_, gl_->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, quad_elements_vbo_)); + GLC(gl_, gl_->BufferData(GL_ELEMENT_ARRAY_BUFFER, + sizeof(GeometryBindingQuadIndex) * 1, &quad_indices, + GL_DYNAMIC_DRAW)); +} + +void DynamicGeometryBinding::InitializeCustomQuad(const gfx::QuadF& quad) { + float uv[] = {0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f}; + InitializeCustomQuadWithUVs(quad, uv); +} + +void DynamicGeometryBinding::InitializeCustomQuadWithUVs(const gfx::QuadF& quad, + const float uv[8]) { + GeometryBindingVertex v0 = { + {quad.p1().x(), quad.p1().y(), 0.0f}, {uv[0], uv[1]}, 0.0f}; + GeometryBindingVertex v1 = { + {quad.p2().x(), quad.p2().y(), 0.0f}, {uv[2], uv[3]}, 1.0f}; + GeometryBindingVertex v2 = { + {quad.p3().x(), quad.p3().y(), 0.0f}, {uv[4], uv[5]}, 2.0f}; + GeometryBindingVertex v3 = { + {quad.p4().x(), quad.p4().y(), 0.0f}, {uv[6], uv[7]}, 3.0f}; + + GeometryBindingQuad local_quad = {v0, v1, v2, v3}; + GeometryBindingQuadIndex quad_index( + static_cast<uint16>(0), static_cast<uint16>(1), static_cast<uint16>(2), + static_cast<uint16>(3), static_cast<uint16>(0), static_cast<uint16>(2)); + + GLC(gl_, gl_->BufferSubData(GL_ARRAY_BUFFER, 0, sizeof(GeometryBindingQuad), + &local_quad)); + GLC(gl_, gl_->BufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, + sizeof(GeometryBindingQuadIndex), &quad_index)); +} + +void DynamicGeometryBinding::PrepareForDraw() { + SetupGLContext(gl_, quad_elements_vbo_, quad_vertices_vbo_); +} + +} // namespace cc diff --git a/cc/output/dynamic_geometry_binding.h b/cc/output/dynamic_geometry_binding.h new file mode 100644 index 0000000..4e4ea3d --- /dev/null +++ b/cc/output/dynamic_geometry_binding.h @@ -0,0 +1,30 @@ +// Copyright 2015 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CC_OUTPUT_DYNAMIC_GEOMETRY_BINDING_H_ +#define CC_OUTPUT_DYNAMIC_GEOMETRY_BINDING_H_ + +#include "cc/output/geometry_binding.h" + +namespace cc { + +class DynamicGeometryBinding { + public: + explicit DynamicGeometryBinding(gpu::gles2::GLES2Interface* gl); + void PrepareForDraw(); + void InitializeCustomQuad(const gfx::QuadF& quad); + void InitializeCustomQuadWithUVs(const gfx::QuadF& quad, const float uv[8]); + + private: + gpu::gles2::GLES2Interface* gl_; + + GLuint quad_vertices_vbo_; + GLuint quad_elements_vbo_; + + DISALLOW_COPY_AND_ASSIGN(DynamicGeometryBinding); +}; + +} // namespace cc + +#endif // CC_OUTPUT_DYNAMIC_GEOMETRY_BINDING_H_ diff --git a/cc/output/geometry_binding.cc b/cc/output/geometry_binding.cc index eda2a5c..88a37de 100644 --- a/cc/output/geometry_binding.cc +++ b/cc/output/geometry_binding.cc @@ -10,70 +10,12 @@ namespace cc { -GeometryBinding::GeometryBinding(gpu::gles2::GLES2Interface* gl, - const gfx::RectF& quad_vertex_rect) - : gl_(gl), quad_vertices_vbo_(0), quad_elements_vbo_(0) { - struct Vertex { - float a_position[3]; - float a_texCoord[2]; - // Index of the vertex, divide by 4 to have the matrix for this quad. - float a_index; - }; - struct Quad { - Vertex v0, v1, v2, v3; - }; - struct QuadIndex { - uint16 data[6]; - }; - - static_assert(sizeof(Quad) == 24 * sizeof(float), - "struct Quad should be densely packed"); - static_assert(sizeof(QuadIndex) == 6 * sizeof(uint16_t), - "struct QuadIndex should be densely packed"); - - Quad quad_list[8]; - QuadIndex quad_index_list[8]; - for (int i = 0; i < 8; i++) { - Vertex v0 = {{quad_vertex_rect.x(), quad_vertex_rect.bottom(), 0.0f, }, - {0.0f, 1.0f, }, i * 4.0f + 0.0f}; - Vertex v1 = {{quad_vertex_rect.x(), quad_vertex_rect.y(), 0.0f, }, - {0.0f, 0.0f, }, i * 4.0f + 1.0f}; - Vertex v2 = {{quad_vertex_rect.right(), quad_vertex_rect.y(), 0.0f, }, - {1.0f, .0f, }, i * 4.0f + 2.0f}; - Vertex v3 = {{quad_vertex_rect.right(), quad_vertex_rect.bottom(), 0.0f, }, - {1.0f, 1.0f, }, i * 4.0f + 3.0f}; - Quad x = {v0, v1, v2, v3}; - quad_list[i] = x; - QuadIndex y = { - {static_cast<uint16>(0 + 4 * i), static_cast<uint16>(1 + 4 * i), - static_cast<uint16>(2 + 4 * i), static_cast<uint16>(3 + 4 * i), - static_cast<uint16>(0 + 4 * i), static_cast<uint16>(2 + 4 * i)}}; - quad_index_list[i] = y; - } - - gl_->GenBuffers(1, &quad_vertices_vbo_); - gl_->GenBuffers(1, &quad_elements_vbo_); - GLC(gl_, gl_->BindBuffer(GL_ARRAY_BUFFER, quad_vertices_vbo_)); - GLC(gl_, - gl_->BufferData( - GL_ARRAY_BUFFER, sizeof(quad_list), quad_list, GL_STATIC_DRAW)); - GLC(gl_, gl_->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, quad_elements_vbo_)); - GLC(gl_, - gl_->BufferData(GL_ELEMENT_ARRAY_BUFFER, - sizeof(quad_index_list), - quad_index_list, - GL_STATIC_DRAW)); -} - -GeometryBinding::~GeometryBinding() { - gl_->DeleteBuffers(1, &quad_vertices_vbo_); - gl_->DeleteBuffers(1, &quad_elements_vbo_); -} +void SetupGLContext(gpu::gles2::GLES2Interface* gl, + GLuint quad_elements_vbo, + GLuint quad_vertices_vbo) { + GLC(gl, gl->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, quad_elements_vbo)); -void GeometryBinding::PrepareForDraw() { - GLC(gl_, gl_->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, quad_elements_vbo_)); - - GLC(gl_, gl_->BindBuffer(GL_ARRAY_BUFFER, quad_vertices_vbo_)); + GLC(gl, gl->BindBuffer(GL_ARRAY_BUFFER, quad_vertices_vbo)); // OpenGL defines the last parameter to VertexAttribPointer as type // "const GLvoid*" even though it is actually an offset into the buffer // object's data store and not a pointer to the client's address space. @@ -83,15 +25,56 @@ void GeometryBinding::PrepareForDraw() { reinterpret_cast<const void*>(5 * sizeof(float)), }; - GLC(gl_, gl_->VertexAttribPointer(PositionAttribLocation(), 3, GL_FLOAT, - false, 6 * sizeof(float), offsets[0])); - GLC(gl_, gl_->VertexAttribPointer(TexCoordAttribLocation(), 2, GL_FLOAT, - false, 6 * sizeof(float), offsets[1])); - GLC(gl_, gl_->VertexAttribPointer(TriangleIndexAttribLocation(), 1, GL_FLOAT, - false, 6 * sizeof(float), offsets[2])); - GLC(gl_, gl_->EnableVertexAttribArray(PositionAttribLocation())); - GLC(gl_, gl_->EnableVertexAttribArray(TexCoordAttribLocation())); - GLC(gl_, gl_->EnableVertexAttribArray(TriangleIndexAttribLocation())); + GLC(gl, + gl->VertexAttribPointer(GeometryBinding::PositionAttribLocation(), 3, + GL_FLOAT, false, 6 * sizeof(float), offsets[0])); + GLC(gl, + gl->VertexAttribPointer(GeometryBinding::TexCoordAttribLocation(), 2, + GL_FLOAT, false, 6 * sizeof(float), offsets[1])); + GLC(gl, + gl->VertexAttribPointer(GeometryBinding::TriangleIndexAttribLocation(), 1, + GL_FLOAT, false, 6 * sizeof(float), offsets[2])); + GLC(gl, + gl->EnableVertexAttribArray(GeometryBinding::PositionAttribLocation())); + GLC(gl, + gl->EnableVertexAttribArray(GeometryBinding::TexCoordAttribLocation())); + GLC(gl, gl->EnableVertexAttribArray( + GeometryBinding::TriangleIndexAttribLocation())); +} + +GeometryBindingQuad::GeometryBindingQuad() { + v0 = {{0, 0, 0}, {0, 0}, 0}; + v1 = {{0, 0, 0}, {0, 0}, 0}; + v2 = {{0, 0, 0}, {0, 0}, 0}; + v3 = {{0, 0, 0}, {0, 0}, 0}; +} + +GeometryBindingQuad::GeometryBindingQuad(const GeometryBindingVertex& vert0, + const GeometryBindingVertex& vert1, + const GeometryBindingVertex& vert2, + const GeometryBindingVertex& vert3) { + v0 = vert0; + v1 = vert1; + v2 = vert2; + v3 = vert3; +} + +GeometryBindingQuadIndex::GeometryBindingQuadIndex() { + memset(data, 0x0, sizeof(data)); +} + +GeometryBindingQuadIndex::GeometryBindingQuadIndex(uint16 index0, + uint16 index1, + uint16 index2, + uint16 index3, + uint16 index4, + uint16 index5) { + data[0] = index0; + data[1] = index1; + data[2] = index2; + data[3] = index3; + data[4] = index4; + data[5] = index5; } } // namespace cc diff --git a/cc/output/geometry_binding.h b/cc/output/geometry_binding.h index cfa21ef..ae68687 100644 --- a/cc/output/geometry_binding.h +++ b/cc/output/geometry_binding.h @@ -6,43 +6,65 @@ #define CC_OUTPUT_GEOMETRY_BINDING_H_ #include "base/basictypes.h" +#include "cc/output/gl_renderer.h" // For the GLC() macro. +#include "gpu/command_buffer/client/gles2_interface.h" #include "third_party/khronos/GLES2/gl2.h" +#include "third_party/khronos/GLES2/gl2ext.h" +#include "ui/gfx/geometry/rect_f.h" namespace gfx { -class RectF; -} -namespace gpu { -namespace gles2 { -class GLES2Interface; -} +class QuadF; +class Quad; +class QuadIndex; +class PointF; } namespace cc { -class GeometryBinding { - public: - GeometryBinding(gpu::gles2::GLES2Interface* gl, - const gfx::RectF& quad_vertex_rect); - ~GeometryBinding(); +struct GeometryBindingVertex { + float a_position[3]; + float a_texCoord[2]; + // Index of the vertex, divide by 4 to have the matrix for this quad. + float a_index; +}; + +struct GeometryBindingQuad { + GeometryBindingQuad(); + GeometryBindingQuad(const GeometryBindingVertex& vert0, + const GeometryBindingVertex& vert1, + const GeometryBindingVertex& vert2, + const GeometryBindingVertex& vert3); + GeometryBindingVertex v0, v1, v2, v3; +}; + +struct GeometryBindingQuadIndex { + GeometryBindingQuadIndex(); + GeometryBindingQuadIndex(uint16 index0, + uint16 index1, + uint16 index2, + uint16 index3, + uint16 index4, + uint16 index5); - void PrepareForDraw(); + uint16 data[6]; +}; + +class DrawQuad; +class DrawPolygon; +struct GeometryBinding { // All layer shaders share the same attribute locations for the vertex // positions and texture coordinates. This allows switching shaders without // rebinding attribute arrays. static int PositionAttribLocation() { return 0; } static int TexCoordAttribLocation() { return 1; } static int TriangleIndexAttribLocation() { return 2; } - - private: - gpu::gles2::GLES2Interface* gl_; - - GLuint quad_vertices_vbo_; - GLuint quad_elements_vbo_; - - DISALLOW_COPY_AND_ASSIGN(GeometryBinding); }; +void SetupGLContext(gpu::gles2::GLES2Interface* gl, + GLuint quad_elements_vbo, + GLuint quad_vertices_vbo); + } // namespace cc #endif // CC_OUTPUT_GEOMETRY_BINDING_H_ diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc index 2016447..613ea4b 100644 --- a/cc/output/gl_renderer.cc +++ b/cc/output/gl_renderer.cc @@ -11,6 +11,11 @@ #include <vector> #include "base/logging.h" +#include "base/memory/scoped_ptr.h" +#include "base/strings/string_split.h" +#include "base/strings/string_util.h" +#include "base/strings/stringprintf.h" +#include "build/build_config.h" #include "base/trace_event/trace_event.h" #include "cc/base/math_util.h" #include "cc/layers/video_layer_impl.h" @@ -18,10 +23,12 @@ #include "cc/output/compositor_frame_metadata.h" #include "cc/output/context_provider.h" #include "cc/output/copy_output_request.h" -#include "cc/output/geometry_binding.h" +#include "cc/output/dynamic_geometry_binding.h" #include "cc/output/gl_frame_data.h" #include "cc/output/output_surface.h" #include "cc/output/render_surface_filters.h" +#include "cc/output/static_geometry_binding.h" +#include "cc/quads/draw_polygon.h" #include "cc/quads/picture_draw_quad.h" #include "cc/quads/render_pass.h" #include "cc/quads/stream_video_draw_quad.h" @@ -324,7 +331,8 @@ GLRenderer::GLRenderer(RendererClient* client, highp_threshold_min_(highp_threshold_min), highp_threshold_cache_(0), use_sync_query_(false), - on_demand_tile_raster_resource_id_(0) { + on_demand_tile_raster_resource_id_(0), + bound_geometry_(NO_BINDING) { DCHECK(gl_); DCHECK(context_support_); @@ -494,10 +502,12 @@ void GLRenderer::DoNoOp() { GLC(gl_, gl_->Flush()); } -void GLRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) { +void GLRenderer::DoDrawQuad(DrawingFrame* frame, + const DrawQuad* quad, + const gfx::QuadF* clip_region) { DCHECK(quad->rect.Contains(quad->visible_rect)); if (quad->material != DrawQuad::TEXTURE_CONTENT) { - FlushTextureQuadCache(); + FlushTextureQuadCache(SHARED_BINDING); } switch (quad->material) { @@ -505,26 +515,31 @@ void GLRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) { NOTREACHED(); break; case DrawQuad::CHECKERBOARD: - DrawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad)); + DrawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad), + clip_region); break; case DrawQuad::DEBUG_BORDER: DrawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad)); break; case DrawQuad::IO_SURFACE_CONTENT: - DrawIOSurfaceQuad(frame, IOSurfaceDrawQuad::MaterialCast(quad)); + DrawIOSurfaceQuad(frame, IOSurfaceDrawQuad::MaterialCast(quad), + clip_region); break; case DrawQuad::PICTURE_CONTENT: // PictureDrawQuad should only be used for resourceless software draws. NOTREACHED(); break; case DrawQuad::RENDER_PASS: - DrawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad)); + DrawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad), + clip_region); break; case DrawQuad::SOLID_COLOR: - DrawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad)); + DrawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad), + clip_region); break; case DrawQuad::STREAM_VIDEO_CONTENT: - DrawStreamVideoQuad(frame, StreamVideoDrawQuad::MaterialCast(quad)); + DrawStreamVideoQuad(frame, StreamVideoDrawQuad::MaterialCast(quad), + clip_region); break; case DrawQuad::SURFACE_CONTENT: // Surface content should be fully resolved to other quad types before @@ -532,19 +547,28 @@ void GLRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) { NOTREACHED(); break; case DrawQuad::TEXTURE_CONTENT: - EnqueueTextureQuad(frame, TextureDrawQuad::MaterialCast(quad)); + EnqueueTextureQuad(frame, TextureDrawQuad::MaterialCast(quad), + clip_region); break; case DrawQuad::TILED_CONTENT: - DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad)); + DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad), clip_region); break; case DrawQuad::YUV_VIDEO_CONTENT: - DrawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad)); + DrawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad), + clip_region); break; } } void GLRenderer::DrawCheckerboardQuad(const DrawingFrame* frame, - const CheckerboardDrawQuad* quad) { + const CheckerboardDrawQuad* quad, + const gfx::QuadF* clip_region) { + // TODO(enne) For now since checkerboards shouldn't be part of a 3D + // context, clipping regions aren't supported so we skip drawing them + // if this becomes the case. + if (clip_region) { + return; + } SetBlendEnabled(quad->ShouldDrawWithBlending()); const TileCheckerboardProgram* program = GetTileCheckerboardProgram(); @@ -588,6 +612,9 @@ void GLRenderer::DrawCheckerboardQuad(const DrawingFrame* frame, program->vertex_shader().matrix_location()); } +// This function does not handle 3D sorting right now, since the debug border +// quads are just drawn as their original quads and not in split pieces. This +// results in some debug border quads drawing over foreground quads. void GLRenderer::DrawDebugBorderQuad(const DrawingFrame* frame, const DebugBorderDrawQuad* quad) { SetBlendEnabled(quad->ShouldDrawWithBlending()); @@ -819,13 +846,56 @@ bool GLRenderer::ShouldApplyBackgroundFilters(DrawingFrame* frame, return true; } +// This takes a gfx::Rect and a clip region quad in the same space, +// and returns a quad with the same proportions in the space -0.5->0.5. +bool GetScaledRegion(const gfx::Rect& rect, + const gfx::QuadF* clip, + gfx::QuadF* scaled_region) { + if (!clip) + return false; + + gfx::PointF p1(((clip->p1().x() - rect.x()) / rect.width()) - 0.5f, + ((clip->p1().y() - rect.y()) / rect.height()) - 0.5f); + gfx::PointF p2(((clip->p2().x() - rect.x()) / rect.width()) - 0.5f, + ((clip->p2().y() - rect.y()) / rect.height()) - 0.5f); + gfx::PointF p3(((clip->p3().x() - rect.x()) / rect.width()) - 0.5f, + ((clip->p3().y() - rect.y()) / rect.height()) - 0.5f); + gfx::PointF p4(((clip->p4().x() - rect.x()) / rect.width()) - 0.5f, + ((clip->p4().y() - rect.y()) / rect.height()) - 0.5f); + *scaled_region = gfx::QuadF(p1, p2, p3, p4); + return true; +} + +// This takes a gfx::Rect and a clip region quad in the same space, +// and returns the proportional uv's in the space 0->1. +bool GetScaledUVs(const gfx::Rect& rect, const gfx::QuadF* clip, float uvs[8]) { + if (!clip) + return false; + + uvs[0] = ((clip->p1().x() - rect.x()) / rect.width()); + uvs[1] = ((clip->p1().y() - rect.y()) / rect.height()); + uvs[2] = ((clip->p2().x() - rect.x()) / rect.width()); + uvs[3] = ((clip->p2().y() - rect.y()) / rect.height()); + uvs[4] = ((clip->p3().x() - rect.x()) / rect.width()); + uvs[5] = ((clip->p3().y() - rect.y()) / rect.height()); + uvs[6] = ((clip->p4().x() - rect.x()) / rect.width()); + uvs[7] = ((clip->p4().y() - rect.y()) / rect.height()); + return true; +} + gfx::Rect GLRenderer::GetBackdropBoundingBoxForRenderPassQuad( DrawingFrame* frame, const RenderPassDrawQuad* quad, const gfx::Transform& contents_device_transform, + const gfx::QuadF* clip_region, bool use_aa) { + gfx::QuadF scaled_region; + if (!GetScaledRegion(quad->rect, clip_region, &scaled_region)) { + scaled_region = SharedGeometryQuad().BoundingBox(); + } + gfx::Rect backdrop_rect = gfx::ToEnclosingRect(MathUtil::MapClippedRect( - contents_device_transform, SharedGeometryQuad().BoundingBox())); + contents_device_transform, scaled_region.BoundingBox())); if (ShouldApplyBackgroundFilters(frame, quad)) { int top, right, bottom, left; @@ -874,7 +944,8 @@ skia::RefPtr<SkImage> GLRenderer::ApplyBackgroundFilters( } void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame, - const RenderPassDrawQuad* quad) { + const RenderPassDrawQuad* quad, + const gfx::QuadF* clip_region) { ScopedResource* contents_texture = render_pass_textures_.get(quad->render_pass_id); if (!contents_texture || !contents_texture->id()) @@ -896,10 +967,8 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame, ShouldAntialiasQuad(contents_device_transform, quad, settings_->force_antialiasing); - if (use_aa) - SetupQuadForAntialiasing(contents_device_transform, quad, - &surface_quad, edge); - + SetupQuadForClippingAndAntialiasing(contents_device_transform, quad, use_aa, + clip_region, &surface_quad, edge); SkXfermode::Mode blend_mode = quad->shared_quad_state->blend_mode; bool use_shaders_for_blending = !CanApplyBlendModeUsingBlendFunc(blend_mode) || @@ -913,7 +982,7 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame, // Compute a bounding box around the pixels that will be visible through // the quad. background_rect = GetBackdropBoundingBoxForRenderPassQuad( - frame, quad, contents_device_transform, use_aa); + frame, quad, contents_device_transform, clip_region, use_aa); if (!background_rect.IsEmpty()) { // The pixels from the filtered background should completely replace the @@ -1238,15 +1307,78 @@ static void SolidColorUniformLocation(T program, uniforms->color_location = program->fragment_shader().color_location(); } +namespace { +// These functions determine if a quad, clipped by a clip_region contains +// the entire {top|bottom|left|right} edge. +bool is_top(const gfx::QuadF* clip_region, const DrawQuad* quad) { + if (!quad->IsTopEdge()) + return false; + if (!clip_region) + return true; + + return std::abs(clip_region->p1().y()) < kAntiAliasingEpsilon && + std::abs(clip_region->p2().y()) < kAntiAliasingEpsilon; +} + +bool is_bottom(const gfx::QuadF* clip_region, const DrawQuad* quad) { + if (!quad->IsBottomEdge()) + return false; + if (!clip_region) + return true; + + return std::abs(clip_region->p3().y() - + quad->shared_quad_state->content_bounds.height()) < + kAntiAliasingEpsilon && + std::abs(clip_region->p4().y() - + quad->shared_quad_state->content_bounds.height()) < + kAntiAliasingEpsilon; +} + +bool is_left(const gfx::QuadF* clip_region, const DrawQuad* quad) { + if (!quad->IsLeftEdge()) + return false; + if (!clip_region) + return true; + + return std::abs(clip_region->p1().x()) < kAntiAliasingEpsilon && + std::abs(clip_region->p4().x()) < kAntiAliasingEpsilon; +} + +bool is_right(const gfx::QuadF* clip_region, const DrawQuad* quad) { + if (!quad->IsRightEdge()) + return false; + if (!clip_region) + return true; + + return std::abs(clip_region->p2().x() - + quad->shared_quad_state->content_bounds.width()) < + kAntiAliasingEpsilon && + std::abs(clip_region->p3().x() - + quad->shared_quad_state->content_bounds.width()) < + kAntiAliasingEpsilon; +} +} // anonymous namespace + static gfx::QuadF GetDeviceQuadWithAntialiasingOnExteriorEdges( const LayerQuad& device_layer_edges, const gfx::Transform& device_transform, + const gfx::QuadF* clip_region, const DrawQuad* quad) { - gfx::Rect tile_rect = quad->visible_rect; - gfx::PointF bottom_right = tile_rect.bottom_right(); - gfx::PointF bottom_left = tile_rect.bottom_left(); - gfx::PointF top_left = tile_rect.origin(); - gfx::PointF top_right = tile_rect.top_right(); + gfx::RectF tile_rect = quad->visible_rect; + gfx::QuadF tile_quad(tile_rect); + + if (clip_region) { + if (quad->material != DrawQuad::RENDER_PASS) { + tile_quad = *clip_region; + } else { + GetScaledRegion(quad->rect, clip_region, &tile_quad); + } + } + + gfx::PointF bottom_right = tile_quad.p3(); + gfx::PointF bottom_left = tile_quad.p4(); + gfx::PointF top_left = tile_quad.p1(); + gfx::PointF top_right = tile_quad.p2(); bool clipped = false; // Map points to device space. We ignore |clipped|, since the result of @@ -1263,16 +1395,26 @@ static gfx::QuadF GetDeviceQuadWithAntialiasingOnExteriorEdges( LayerQuad::Edge right_edge(top_right, bottom_right); // Only apply anti-aliasing to edges not clipped by culling or scissoring. - if (quad->IsTopEdge() && tile_rect.y() == quad->rect.y()) + // If an edge is degenerate we do not want to replace it with a "proper" edge + // as that will cause the quad to possibly expand is strange ways. + if (!top_edge.degenerate() && is_top(clip_region, quad) && + tile_rect.y() == quad->rect.y()) { top_edge = device_layer_edges.top(); - if (quad->IsLeftEdge() && tile_rect.x() == quad->rect.x()) + } + if (!left_edge.degenerate() && is_left(clip_region, quad) && + tile_rect.x() == quad->rect.x()) { left_edge = device_layer_edges.left(); - if (quad->IsRightEdge() && tile_rect.right() == quad->rect.right()) + } + if (!right_edge.degenerate() && is_right(clip_region, quad) && + tile_rect.right() == quad->rect.right()) { right_edge = device_layer_edges.right(); - if (quad->IsBottomEdge() && tile_rect.bottom() == quad->rect.bottom()) + } + if (!bottom_edge.degenerate() && is_bottom(clip_region, quad) && + tile_rect.bottom() == quad->rect.bottom()) { bottom_edge = device_layer_edges.bottom(); + } - float sign = gfx::QuadF(tile_rect).IsCounterClockwise() ? -1 : 1; + float sign = tile_quad.IsCounterClockwise() ? -1 : 1; bottom_edge.scale(sign); left_edge.scale(sign); top_edge.scale(sign); @@ -1282,6 +1424,32 @@ static gfx::QuadF GetDeviceQuadWithAntialiasingOnExteriorEdges( return LayerQuad(left_edge, top_edge, right_edge, bottom_edge).ToQuadF(); } +float GetTotalQuadError(const gfx::QuadF* clipped_quad, + const gfx::QuadF* ideal_rect) { + return (clipped_quad->p1() - ideal_rect->p1()).LengthSquared() + + (clipped_quad->p2() - ideal_rect->p2()).LengthSquared() + + (clipped_quad->p3() - ideal_rect->p3()).LengthSquared() + + (clipped_quad->p4() - ideal_rect->p4()).LengthSquared(); +} + +// Attempt to rotate the clipped quad until it lines up the most +// correctly. This is necessary because we check the edges of this +// quad against the expected left/right/top/bottom for anti-aliasing. +void AlignQuadToBoundingBox(gfx::QuadF* clipped_quad) { + gfx::QuadF bounding_quad = gfx::QuadF(clipped_quad->BoundingBox()); + gfx::QuadF best_rotation = *clipped_quad; + float least_error_amount = GetTotalQuadError(clipped_quad, &bounding_quad); + for (size_t i = 1; i < 4; ++i) { + clipped_quad->Realign(1); + float new_error = GetTotalQuadError(clipped_quad, &bounding_quad); + if (new_error < least_error_amount) { + least_error_amount = new_error; + best_rotation = *clipped_quad; + } + } + *clipped_quad = best_rotation; +} + // static bool GLRenderer::ShouldAntialiasQuad(const gfx::Transform& device_transform, const DrawQuad* quad, @@ -1313,18 +1481,39 @@ bool GLRenderer::ShouldAntialiasQuad(const gfx::Transform& device_transform, } // static -void GLRenderer::SetupQuadForAntialiasing( +void GLRenderer::SetupQuadForClippingAndAntialiasing( const gfx::Transform& device_transform, const DrawQuad* quad, + bool use_aa, + const gfx::QuadF* clip_region, gfx::QuadF* local_quad, float edge[24]) { bool is_render_pass_quad = (quad->material == DrawQuad::RENDER_PASS); - gfx::RectF content_rect = - is_render_pass_quad ? QuadVertexRect() : quad->visibleContentRect(); - + gfx::QuadF rotated_clip; + const gfx::QuadF* local_clip_region = clip_region; + if (local_clip_region) { + rotated_clip = *clip_region; + AlignQuadToBoundingBox(&rotated_clip); + local_clip_region = &rotated_clip; + } + + gfx::QuadF content_rect = is_render_pass_quad + ? gfx::QuadF(QuadVertexRect()) + : gfx::QuadF(quad->visibleContentRect()); + if (!use_aa) { + if (local_clip_region) { + if (!is_render_pass_quad) { + content_rect = *local_clip_region; + } else { + GetScaledRegion(quad->rect, local_clip_region, &content_rect); + } + *local_quad = content_rect; + } + return; + } bool clipped = false; gfx::QuadF device_layer_quad = - MathUtil::MapQuad(device_transform, gfx::QuadF(content_rect), &clipped); + MathUtil::MapQuad(device_transform, content_rect, &clipped); LayerQuad device_layer_bounds(gfx::QuadF(device_layer_quad.BoundingBox())); device_layer_bounds.InflateAntiAliasingDistance(); @@ -1335,16 +1524,25 @@ void GLRenderer::SetupQuadForAntialiasing( device_layer_edges.ToFloatArray(edge); device_layer_bounds.ToFloatArray(&edge[12]); + // If we have a clip region then we are split, and therefore + // by necessity, at least one of our edges is not an external + // one. + bool is_full_rect = quad->visible_rect == quad->rect; + + bool region_contains_all_outside_edges = + is_full_rect && + (is_top(local_clip_region, quad) && is_left(local_clip_region, quad) && + is_bottom(local_clip_region, quad) && is_right(local_clip_region, quad)); + bool use_aa_on_all_four_edges = - is_render_pass_quad || - (quad->IsTopEdge() && quad->IsLeftEdge() && quad->IsBottomEdge() && - quad->IsRightEdge() && quad->visible_rect == quad->rect); + !local_clip_region && + (is_render_pass_quad || region_contains_all_outside_edges); gfx::QuadF device_quad = use_aa_on_all_four_edges ? device_layer_edges.ToQuadF() : GetDeviceQuadWithAntialiasingOnExteriorEdges( - device_layer_edges, device_transform, quad); + device_layer_edges, device_transform, local_clip_region, quad); // Map device space quad to local space. device_transform has no 3d // component since it was flattened, so we don't need to project. We should @@ -1360,7 +1558,8 @@ void GLRenderer::SetupQuadForAntialiasing( } void GLRenderer::DrawSolidColorQuad(const DrawingFrame* frame, - const SolidColorDrawQuad* quad) { + const SolidColorDrawQuad* quad, + const gfx::QuadF* clip_region) { gfx::Rect tile_rect = quad->visible_rect; SkColor color = quad->color; @@ -1384,10 +1583,11 @@ void GLRenderer::DrawSolidColorQuad(const DrawingFrame* frame, bool use_aa = settings_->allow_antialiasing && !quad->force_anti_aliasing_off && ShouldAntialiasQuad(device_transform, quad, force_aa); + SetupQuadForClippingAndAntialiasing(device_transform, quad, use_aa, + clip_region, &local_quad, edge); SolidColorProgramUniforms uniforms; if (use_aa) { - SetupQuadForAntialiasing(device_transform, quad, &local_quad, edge); SolidColorUniformLocation(GetSolidColorProgramAA(), &uniforms); } else { SolidColorUniformLocation(GetSolidColorProgram(), &uniforms); @@ -1458,13 +1658,15 @@ static void TileUniformLocation(T program, TileProgramUniforms* uniforms) { } void GLRenderer::DrawTileQuad(const DrawingFrame* frame, - const TileDrawQuad* quad) { - DrawContentQuad(frame, quad, quad->resource_id); + const TileDrawQuad* quad, + const gfx::QuadF* clip_region) { + DrawContentQuad(frame, quad, quad->resource_id, clip_region); } void GLRenderer::DrawContentQuad(const DrawingFrame* frame, const ContentDrawQuadBase* quad, - ResourceProvider::ResourceId resource_id) { + ResourceProvider::ResourceId resource_id, + const gfx::QuadF* clip_region) { gfx::Transform device_transform = frame->window_matrix * frame->projection_matrix * quad->quadTransform(); device_transform.FlattenTo2d(); @@ -1476,15 +1678,16 @@ void GLRenderer::DrawContentQuad(const DrawingFrame* frame, // similar to the way DrawContentQuadNoAA works and then consider // combining DrawContentQuadAA and DrawContentQuadNoAA into one method. if (use_aa) - DrawContentQuadAA(frame, quad, resource_id, device_transform); + DrawContentQuadAA(frame, quad, resource_id, device_transform, clip_region); else - DrawContentQuadNoAA(frame, quad, resource_id); + DrawContentQuadNoAA(frame, quad, resource_id, clip_region); } void GLRenderer::DrawContentQuadAA(const DrawingFrame* frame, const ContentDrawQuadBase* quad, ResourceProvider::ResourceId resource_id, - const gfx::Transform& device_transform) { + const gfx::Transform& device_transform, + const gfx::QuadF* clip_region) { if (!device_transform.IsInvertible()) return; @@ -1529,8 +1732,8 @@ void GLRenderer::DrawContentQuadAA(const DrawingFrame* frame, gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect)); float edge[24]; - SetupQuadForAntialiasing(device_transform, quad, &local_quad, edge); - + SetupQuadForClippingAndAntialiasing(device_transform, quad, true, clip_region, + &local_quad, edge); ResourceProvider::ScopedSamplerGL quad_resource_lock( resource_provider_, resource_id, quad->nearest_neighbor ? GL_NEAREST : GL_LINEAR); @@ -1608,7 +1811,8 @@ void GLRenderer::DrawContentQuadAA(const DrawingFrame* frame, void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame, const ContentDrawQuadBase* quad, - ResourceProvider::ResourceId resource_id) { + ResourceProvider::ResourceId resource_id, + const gfx::QuadF* clip_region) { gfx::RectF tex_coord_rect = MathUtil::ScaleRectProportional( quad->tex_coord_rect, quad->rect, quad->visible_rect); float tex_to_geom_scale_x = quad->rect.width() / quad->tex_coord_rect.width(); @@ -1682,17 +1886,37 @@ void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame, // does, then vertices will match the texture mapping in the vertex buffer. // The method SetShaderQuadF() changes the order of vertices and so it's // not used here. - - gfx::RectF tile_rect = quad->visible_rect; + gfx::QuadF tile_rect(quad->visible_rect); + float width = quad->visible_rect.width(); + float height = quad->visible_rect.height(); + gfx::PointF top_left = quad->visible_rect.origin(); + if (clip_region) { + tile_rect = *clip_region; + float gl_uv[8] = { + (tile_rect.p4().x() - top_left.x()) / width, + (tile_rect.p4().y() - top_left.y()) / height, + (tile_rect.p1().x() - top_left.x()) / width, + (tile_rect.p1().y() - top_left.y()) / height, + (tile_rect.p2().x() - top_left.x()) / width, + (tile_rect.p2().y() - top_left.y()) / height, + (tile_rect.p3().x() - top_left.x()) / width, + (tile_rect.p3().y() - top_left.y()) / height, + }; + PrepareGeometry(CLIPPED_BINDING); + clipped_geometry_->InitializeCustomQuadWithUVs( + gfx::QuadF(quad->visible_rect), gl_uv); + } else { + PrepareGeometry(SHARED_BINDING); + } float gl_quad[8] = { - tile_rect.x(), - tile_rect.bottom(), - tile_rect.x(), - tile_rect.y(), - tile_rect.right(), - tile_rect.y(), - tile_rect.right(), - tile_rect.bottom(), + tile_rect.p4().x(), + tile_rect.p4().y(), + tile_rect.p1().x(), + tile_rect.p1().y(), + tile_rect.p2().x(), + tile_rect.p2().y(), + tile_rect.p3().x(), + tile_rect.p3().y(), }; GLC(gl_, gl_->Uniform2fv(uniforms.quad_location, 4, gl_quad)); @@ -1705,7 +1929,8 @@ void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame, } void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame, - const YUVVideoDrawQuad* quad) { + const YUVVideoDrawQuad* quad, + const gfx::QuadF* clip_region) { SetBlendEnabled(quad->ShouldDrawWithBlending()); TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired( @@ -1845,15 +2070,31 @@ void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame, break; } + // The transform and vertex data are used to figure out the extents that the + // un-antialiased quad should have and which vertex this is and the float + // quad passed in via uniform is the actual geometry that gets used to draw + // it. This is why this centered rect is used and not the original quad_rect. + gfx::RectF tile_rect = quad->visible_rect; GLC(gl_, gl_->UniformMatrix3fv(yuv_matrix_location, 1, 0, yuv_to_rgb)); GLC(gl_, gl_->Uniform3fv(yuv_adj_location, 1, yuv_adjust)); SetShaderOpacity(quad->opacity(), alpha_location); - DrawQuadGeometry(frame, quad->quadTransform(), quad->rect, matrix_location); + if (!clip_region) { + DrawQuadGeometry(frame, quad->quadTransform(), tile_rect, matrix_location); + } else { + float uvs[8] = {0}; + GetScaledUVs(quad->visible_rect, clip_region, uvs); + gfx::QuadF region_quad = *clip_region; + region_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height()); + region_quad -= gfx::Vector2dF(0.5f, 0.5f); + DrawQuadGeometryClippedByQuadF(frame, quad->quadTransform(), tile_rect, + region_quad, matrix_location, uvs); + } } void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame, - const StreamVideoDrawQuad* quad) { + const StreamVideoDrawQuad* quad, + const gfx::QuadF* clip_region) { SetBlendEnabled(quad->ShouldDrawWithBlending()); static float gl_matrix[16]; @@ -1884,10 +2125,19 @@ void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame, SetShaderOpacity(quad->opacity(), program->fragment_shader().alpha_location()); - DrawQuadGeometry(frame, - quad->quadTransform(), - quad->rect, - program->vertex_shader().matrix_location()); + if (!clip_region) { + DrawQuadGeometry(frame, quad->quadTransform(), quad->rect, + program->vertex_shader().matrix_location()); + } else { + gfx::QuadF region_quad(*clip_region); + region_quad.Scale(1.0f / quad->rect.width(), 1.0f / quad->rect.height()); + region_quad -= gfx::Vector2dF(0.5f, 0.5f); + float uvs[8] = {0}; + GetScaledUVs(quad->visible_rect, clip_region, uvs); + DrawQuadGeometryClippedByQuadF( + frame, quad->quadTransform(), quad->rect, region_quad, + program->vertex_shader().matrix_location(), uvs); + } } struct TextureProgramBinding { @@ -1903,6 +2153,7 @@ struct TextureProgramBinding { int program_id; int sampler_location; int matrix_location; + int transform_location; int background_color_location; }; @@ -1918,11 +2169,13 @@ struct TexTransformTextureProgramBinding : TextureProgramBinding { int vertex_opacity_location; }; -void GLRenderer::FlushTextureQuadCache() { +void GLRenderer::FlushTextureQuadCache(BoundGeometry flush_binding) { // Check to see if we have anything to draw. if (draw_cache_.program_id == -1) return; + PrepareGeometry(flush_binding); + // Set the correct blending mode. SetBlendEnabled(draw_cache_.needs_blending); @@ -1983,10 +2236,26 @@ void GLRenderer::FlushTextureQuadCache() { draw_cache_.uv_xform_data.resize(0); draw_cache_.vertex_opacity_data.resize(0); draw_cache_.matrix_data.resize(0); + + // If we had a clipped binding, prepare the shared binding for the + // next inserts. + if (flush_binding == CLIPPED_BINDING) { + PrepareGeometry(SHARED_BINDING); + } } void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame, - const TextureDrawQuad* quad) { + const TextureDrawQuad* quad, + const gfx::QuadF* clip_region) { + // If we have a clip_region then we have to render the next quad + // with dynamic geometry, therefore we must flush all pending + // texture quads. + if (clip_region) { + // We send in false here because we want to flush what's currently in the + // queue using the shared_geometry and not clipped_geometry + FlushTextureQuadCache(SHARED_BINDING); + } + TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired( gl_, &highp_threshold_cache_, @@ -2018,7 +2287,7 @@ void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame, draw_cache_.nearest_neighbor != quad->nearest_neighbor || draw_cache_.background_color != quad->background_color || draw_cache_.matrix_data.size() >= 8) { - FlushTextureQuadCache(); + FlushTextureQuadCache(SHARED_BINDING); draw_cache_.program_id = binding.program_id; draw_cache_.resource_id = resource_id; draw_cache_.needs_blending = quad->ShouldDrawWithBlending(); @@ -2033,7 +2302,12 @@ void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame, } // Generate the uv-transform - draw_cache_.uv_xform_data.push_back(UVTransform(quad)); + if (!clip_region) { + draw_cache_.uv_xform_data.push_back(UVTransform(quad)); + } else { + Float4 uv_transform = {{0.0f, 0.0f, 1.0f, 1.0f}}; + draw_cache_.uv_xform_data.push_back(uv_transform); + } // Generate the vertex opacity const float opacity = quad->opacity(); @@ -2050,10 +2324,32 @@ void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame, Float16 m; quad_rect_matrix.matrix().asColMajorf(m.data); draw_cache_.matrix_data.push_back(m); + + if (clip_region) { + gfx::QuadF scaled_region; + if (!GetScaledRegion(quad->rect, clip_region, &scaled_region)) { + scaled_region = SharedGeometryQuad().BoundingBox(); + } + // Both the scaled region and the SharedGeomtryQuad are in the space + // -0.5->0.5. We need to move that to the space 0->1. + float uv[8]; + uv[0] = scaled_region.p1().x() + 0.5f; + uv[1] = scaled_region.p1().y() + 0.5f; + uv[2] = scaled_region.p2().x() + 0.5f; + uv[3] = scaled_region.p2().y() + 0.5f; + uv[4] = scaled_region.p3().x() + 0.5f; + uv[5] = scaled_region.p3().y() + 0.5f; + uv[6] = scaled_region.p4().x() + 0.5f; + uv[7] = scaled_region.p4().y() + 0.5f; + PrepareGeometry(CLIPPED_BINDING); + clipped_geometry_->InitializeCustomQuadWithUVs(scaled_region, uv); + FlushTextureQuadCache(CLIPPED_BINDING); + } } void GLRenderer::DrawIOSurfaceQuad(const DrawingFrame* frame, - const IOSurfaceDrawQuad* quad) { + const IOSurfaceDrawQuad* quad, + const gfx::QuadF* clip_region) { SetBlendEnabled(quad->ShouldDrawWithBlending()); TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired( @@ -2092,8 +2388,15 @@ void GLRenderer::DrawIOSurfaceQuad(const DrawingFrame* frame, DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_)); GLC(gl_, gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, lock.texture_id())); - DrawQuadGeometry( - frame, quad->quadTransform(), quad->rect, binding.matrix_location); + if (!clip_region) { + DrawQuadGeometry(frame, quad->quadTransform(), quad->rect, + binding.matrix_location); + } else { + float uvs[8] = {0}; + GetScaledUVs(quad->visible_rect, clip_region, uvs); + DrawQuadGeometryClippedByQuadF(frame, quad->quadTransform(), quad->rect, + *clip_region, binding.matrix_location, uvs); + } GLC(gl_, gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, 0)); } @@ -2114,7 +2417,9 @@ void GLRenderer::FinishDrawingFrame(DrawingFrame* frame) { ScheduleOverlays(frame); } -void GLRenderer::FinishDrawingQuadList() { FlushTextureQuadCache(); } +void GLRenderer::FinishDrawingQuadList() { + FlushTextureQuadCache(SHARED_BINDING); +} bool GLRenderer::FlippedFramebuffer(const DrawingFrame* frame) const { if (frame->current_render_pass != frame->root_render_pass) @@ -2131,7 +2436,7 @@ void GLRenderer::EnsureScissorTestEnabled() { if (is_scissor_enabled_) return; - FlushTextureQuadCache(); + FlushTextureQuadCache(SHARED_BINDING); GLC(gl_, gl_->Enable(GL_SCISSOR_TEST)); is_scissor_enabled_ = true; } @@ -2140,7 +2445,7 @@ void GLRenderer::EnsureScissorTestDisabled() { if (!is_scissor_enabled_) return; - FlushTextureQuadCache(); + FlushTextureQuadCache(SHARED_BINDING); GLC(gl_, gl_->Disable(GL_SCISSOR_TEST)); is_scissor_enabled_ = false; } @@ -2209,10 +2514,34 @@ void GLRenderer::SetUseProgram(unsigned program) { program_shadow_ = program; } +void GLRenderer::DrawQuadGeometryClippedByQuadF( + const DrawingFrame* frame, + const gfx::Transform& draw_transform, + const gfx::RectF& quad_rect, + const gfx::QuadF& clipping_region_quad, + int matrix_location, + const float* uvs) { + PrepareGeometry(CLIPPED_BINDING); + if (uvs) { + clipped_geometry_->InitializeCustomQuadWithUVs(clipping_region_quad, uvs); + } else { + clipped_geometry_->InitializeCustomQuad(clipping_region_quad); + } + gfx::Transform quad_rect_matrix; + QuadRectTransform(&quad_rect_matrix, draw_transform, quad_rect); + static float gl_matrix[16]; + ToGLMatrix(&gl_matrix[0], frame->projection_matrix * quad_rect_matrix); + GLC(gl_, gl_->UniformMatrix4fv(matrix_location, 1, false, &gl_matrix[0])); + + GLC(gl_, gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, + reinterpret_cast<const void*>(0))); +} + void GLRenderer::DrawQuadGeometry(const DrawingFrame* frame, const gfx::Transform& draw_transform, const gfx::RectF& quad_rect, int matrix_location) { + PrepareGeometry(SHARED_BINDING); gfx::Transform quad_rect_matrix; QuadRectTransform(&quad_rect_matrix, draw_transform, quad_rect); static float gl_matrix[16]; @@ -2275,6 +2604,7 @@ void GLRenderer::EnforceMemoryPolicy() { output_surface_->context_provider()->DeleteCachedResources(); GLC(gl_, gl_->Flush()); } + PrepareGeometry(NO_BINDING); } void GLRenderer::DiscardBackbuffer() { @@ -2606,7 +2936,7 @@ void GLRenderer::SetScissorTestRect(const gfx::Rect& scissor_rect) { return; scissor_rect_ = scissor_rect; - FlushTextureQuadCache(); + FlushTextureQuadCache(SHARED_BINDING); GLC(gl_, gl_->Scissor(scissor_rect.x(), scissor_rect.y(), @@ -2631,8 +2961,27 @@ void GLRenderer::InitializeSharedObjects() { // Create an FBO for doing offscreen rendering. GLC(gl_, gl_->GenFramebuffers(1, &offscreen_framebuffer_id_)); - shared_geometry_ = make_scoped_ptr( - new GeometryBinding(gl_, QuadVertexRect())); + shared_geometry_ = + make_scoped_ptr(new StaticGeometryBinding(gl_, QuadVertexRect())); + clipped_geometry_ = make_scoped_ptr(new DynamicGeometryBinding(gl_)); +} + +void GLRenderer::PrepareGeometry(BoundGeometry binding) { + if (binding == bound_geometry_) { + return; + } + + switch (binding) { + case SHARED_BINDING: + shared_geometry_->PrepareForDraw(); + break; + case CLIPPED_BINDING: + clipped_geometry_->PrepareForDraw(); + break; + case NO_BINDING: + break; + } + bound_geometry_ = binding; } const GLRenderer::TileCheckerboardProgram* @@ -3112,8 +3461,8 @@ void GLRenderer::ReinitializeGLState() { void GLRenderer::RestoreGLState() { // This restores the current GLRenderer state to the GL context. - - shared_geometry_->PrepareForDraw(); + bound_geometry_ = NO_BINDING; + PrepareGeometry(SHARED_BINDING); GLC(gl_, gl_->Disable(GL_DEPTH_TEST)); GLC(gl_, gl_->Disable(GL_CULL_FACE)); diff --git a/cc/output/gl_renderer.h b/cc/output/gl_renderer.h index 01668ab..27f2c42 100644 --- a/cc/output/gl_renderer.h +++ b/cc/output/gl_renderer.h @@ -39,7 +39,8 @@ class ScopedResource; class StreamVideoDrawQuad; class TextureDrawQuad; class TextureMailboxDeleter; -class GeometryBinding; +class StaticGeometryBinding; +class DynamicGeometryBinding; class ScopedEnsureFramebufferAllocation; // Class that handles drawing of composited render layers using GL. @@ -85,7 +86,7 @@ class CC_EXPORT GLRenderer : public DirectRenderer { bool IsBackbufferDiscarded() const { return is_backbuffer_discarded_; } const gfx::QuadF& SharedGeometryQuad() const { return shared_geometry_quad_; } - const GeometryBinding* SharedGeometry() const { + const StaticGeometryBinding* SharedGeometry() const { return shared_geometry_.get(); } @@ -96,7 +97,8 @@ class CC_EXPORT GLRenderer : public DirectRenderer { ResourceFormat texture_format, const gfx::Rect& device_rect); void ReleaseRenderPassTextures(); - + enum BoundGeometry { NO_BINDING, SHARED_BINDING, CLIPPED_BINDING }; + void PrepareGeometry(BoundGeometry geometry_to_bind); void SetStencilEnabled(bool enabled); bool stencil_enabled() const { return stencil_shadow_; } void SetBlendEnabled(bool enabled); @@ -112,7 +114,9 @@ class CC_EXPORT GLRenderer : public DirectRenderer { bool draw_rect_covers_full_surface) override; void ClearFramebuffer(DrawingFrame* frame, bool has_external_stencil_test) override; - void DoDrawQuad(DrawingFrame* frame, const class DrawQuad*) override; + void DoDrawQuad(DrawingFrame* frame, + const class DrawQuad*, + const gfx::QuadF* draw_region) override; void BeginDrawingFrame(DrawingFrame* frame) override; void FinishDrawingFrame(DrawingFrame* frame) override; bool FlippedFramebuffer(const DrawingFrame* frame) const override; @@ -132,10 +136,13 @@ class CC_EXPORT GLRenderer : public DirectRenderer { // Inflate the quad and fill edge array for fragment shader. // |local_quad| is set to inflated quad. |edge| array is filled with // inflated quad's edge data. - static void SetupQuadForAntialiasing(const gfx::Transform& device_transform, - const DrawQuad* quad, - gfx::QuadF* local_quad, - float edge[24]); + static void SetupQuadForClippingAndAntialiasing( + const gfx::Transform& device_transform, + const DrawQuad* quad, + bool use_aa, + const gfx::QuadF* clip_region, + gfx::QuadF* local_quad, + float edge[24]); private: friend class GLRendererShaderPixelTest; @@ -144,7 +151,8 @@ class CC_EXPORT GLRenderer : public DirectRenderer { static void ToGLMatrix(float* gl_matrix, const gfx::Transform& transform); void DrawCheckerboardQuad(const DrawingFrame* frame, - const CheckerboardDrawQuad* quad); + const CheckerboardDrawQuad* quad, + const gfx::QuadF* clip_region); void DrawDebugBorderQuad(const DrawingFrame* frame, const DebugBorderDrawQuad* quad); static bool IsDefaultBlendMode(SkXfermode::Mode blend_mode) { @@ -158,6 +166,7 @@ class CC_EXPORT GLRenderer : public DirectRenderer { DrawingFrame* frame, const RenderPassDrawQuad* quad, const gfx::Transform& contents_device_transform, + const gfx::QuadF* clip_region, bool use_aa); scoped_ptr<ScopedResource> GetBackdropTexture(const gfx::Rect& bounding_rect); @@ -168,34 +177,56 @@ class CC_EXPORT GLRenderer : public DirectRenderer { const RenderPassDrawQuad* quad, ScopedResource* background_texture); - void DrawRenderPassQuad(DrawingFrame* frame, const RenderPassDrawQuad* quad); + void DrawRenderPassQuad(DrawingFrame* frame, + const RenderPassDrawQuad* quadi, + const gfx::QuadF* clip_region); void DrawSolidColorQuad(const DrawingFrame* frame, - const SolidColorDrawQuad* quad); + const SolidColorDrawQuad* quad, + const gfx::QuadF* clip_region); void DrawStreamVideoQuad(const DrawingFrame* frame, - const StreamVideoDrawQuad* quad); + const StreamVideoDrawQuad* quad, + const gfx::QuadF* clip_region); + void DrawTextureQuad(const DrawingFrame* frame, + const TextureDrawQuad* quad, + const gfx::QuadF* clip_region); void EnqueueTextureQuad(const DrawingFrame* frame, - const TextureDrawQuad* quad); - void FlushTextureQuadCache(); + const TextureDrawQuad* quad, + const gfx::QuadF* clip_region); + void FlushTextureQuadCache(BoundGeometry flush_binding); void DrawIOSurfaceQuad(const DrawingFrame* frame, - const IOSurfaceDrawQuad* quad); - void DrawTileQuad(const DrawingFrame* frame, const TileDrawQuad* quad); + const IOSurfaceDrawQuad* quad, + const gfx::QuadF* clip_region); + void DrawTileQuad(const DrawingFrame* frame, + const TileDrawQuad* quad, + const gfx::QuadF* clip_region); void DrawContentQuad(const DrawingFrame* frame, const ContentDrawQuadBase* quad, - ResourceProvider::ResourceId resource_id); + ResourceProvider::ResourceId resource_id, + const gfx::QuadF* clip_region); void DrawContentQuadAA(const DrawingFrame* frame, const ContentDrawQuadBase* quad, ResourceProvider::ResourceId resource_id, - const gfx::Transform& device_transform); + const gfx::Transform& device_transform, + const gfx::QuadF* clip_region); void DrawContentQuadNoAA(const DrawingFrame* frame, const ContentDrawQuadBase* quad, - ResourceProvider::ResourceId resource_id); + ResourceProvider::ResourceId resource_id, + const gfx::QuadF* clip_region); void DrawYUVVideoQuad(const DrawingFrame* frame, - const YUVVideoDrawQuad* quad); + const YUVVideoDrawQuad* quad, + const gfx::QuadF* clip_region); void DrawPictureQuad(const DrawingFrame* frame, - const PictureDrawQuad* quad); + const PictureDrawQuad* quad, + const gfx::QuadF* clip_region); void SetShaderOpacity(float opacity, int alpha_location); void SetShaderQuadF(const gfx::QuadF& quad, int quad_location); + void DrawQuadGeometryClippedByQuadF(const DrawingFrame* frame, + const gfx::Transform& draw_transform, + const gfx::RectF& quad_rect, + const gfx::QuadF& clipping_region_quad, + int matrix_location, + const float uv[8]); void DrawQuadGeometry(const DrawingFrame* frame, const gfx::Transform& draw_transform, const gfx::RectF& quad_rect, @@ -237,7 +268,8 @@ class CC_EXPORT GLRenderer : public DirectRenderer { unsigned offscreen_framebuffer_id_; - scoped_ptr<GeometryBinding> shared_geometry_; + scoped_ptr<StaticGeometryBinding> shared_geometry_; + scoped_ptr<DynamicGeometryBinding> clipped_geometry_; gfx::QuadF shared_geometry_quad_; // This block of bindings defines all of the programs used by the compositor @@ -480,7 +512,7 @@ class CC_EXPORT GLRenderer : public DirectRenderer { SkBitmap on_demand_tile_raster_bitmap_; ResourceProvider::ResourceId on_demand_tile_raster_resource_id_; - + BoundGeometry bound_geometry_; DISALLOW_COPY_AND_ASSIGN(GLRenderer); }; diff --git a/cc/output/overlay_unittest.cc b/cc/output/overlay_unittest.cc index 5590ec3..9090621 100644 --- a/cc/output/overlay_unittest.cc +++ b/cc/output/overlay_unittest.cc @@ -775,7 +775,10 @@ class OverlayInfoRendererGL : public GLRenderer { 0), expect_overlays_(false) {} - MOCK_METHOD2(DoDrawQuad, void(DrawingFrame* frame, const DrawQuad* quad)); + MOCK_METHOD3(DoDrawQuad, + void(DrawingFrame* frame, + const DrawQuad* quad, + const gfx::QuadF* draw_region)); using GLRenderer::BeginDrawingFrame; @@ -875,7 +878,7 @@ TEST_F(GLRendererWithOverlaysTest, OverlayQuadNotDrawn) { // Candidate pass was taken out and extra skipped pass added, // so only draw 2 quads. - EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(2); + EXPECT_CALL(*renderer_, DoDrawQuad(_, _, _)).Times(2); EXPECT_CALL(scheduler_, Schedule(1, gfx::OVERLAY_TRANSFORM_NONE, @@ -913,7 +916,7 @@ TEST_F(GLRendererWithOverlaysTest, OccludedQuadDrawn) { pass_list.push_back(pass.Pass()); // 3 quads in the pass, all should draw. - EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(3); + EXPECT_CALL(*renderer_, DoDrawQuad(_, _, _)).Times(3); EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(0); renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false); @@ -946,7 +949,7 @@ TEST_F(GLRendererWithOverlaysTest, NoValidatorNoOverlay) { pass_list.push_back(pass.Pass()); // Should see no overlays. - EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(3); + EXPECT_CALL(*renderer_, DoDrawQuad(_, _, _)).Times(3); EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(0); renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false); diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc index b30b0a5..295fc84 100644 --- a/cc/output/renderer_pixeltest.cc +++ b/cc/output/renderer_pixeltest.cc @@ -111,6 +111,52 @@ void CreateTestRenderPassDrawQuad(const SharedQuadState* shared_state, FilterOperations()); // background filters } +void CreateTestTwoColoredTextureDrawQuad(const gfx::Rect& rect, + SkColor texel_color, + SkColor texel_stripe_color, + SkColor background_color, + bool premultiplied_alpha, + const SharedQuadState* shared_state, + ResourceProvider* resource_provider, + RenderPass* render_pass) { + SkPMColor pixel_color = premultiplied_alpha + ? SkPreMultiplyColor(texel_color) + : SkPackARGB32NoCheck(SkColorGetA(texel_color), + SkColorGetR(texel_color), + SkColorGetG(texel_color), + SkColorGetB(texel_color)); + SkPMColor pixel_stripe_color = + premultiplied_alpha + ? SkPreMultiplyColor(texel_stripe_color) + : SkPackARGB32NoCheck(SkColorGetA(texel_stripe_color), + SkColorGetR(texel_stripe_color), + SkColorGetG(texel_stripe_color), + SkColorGetB(texel_stripe_color)); + std::vector<uint32_t> pixels(rect.size().GetArea(), pixel_color); + for (int i = rect.height() / 4; i < (rect.height() * 3 / 4); ++i) { + for (int k = rect.width() / 4; k < (rect.width() * 3 / 4); ++k) { + pixels[i * rect.width() + k] = pixel_stripe_color; + } + } + ResourceProvider::ResourceId resource = resource_provider->CreateResource( + rect.size(), GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, + RGBA_8888); + resource_provider->SetPixels(resource, + reinterpret_cast<uint8_t*>(&pixels.front()), + rect, rect, gfx::Vector2d()); + + float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f}; + const gfx::PointF uv_top_left(0.0f, 0.0f); + const gfx::PointF uv_bottom_right(1.0f, 1.0f); + const bool flipped = false; + const bool nearest_neighbor = false; + TextureDrawQuad* quad = + render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>(); + quad->SetNew(shared_state, rect, gfx::Rect(), rect, resource, + premultiplied_alpha, uv_top_left, uv_bottom_right, + background_color, vertex_opacity, flipped, nearest_neighbor); +} + void CreateTestTextureDrawQuad(const gfx::Rect& rect, SkColor texel_color, SkColor background_color, @@ -135,20 +181,216 @@ void CreateTestTextureDrawQuad(const gfx::Rect& rect, float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f}; + const gfx::PointF uv_top_left(0.0f, 0.0f); + const gfx::PointF uv_bottom_right(1.0f, 1.0f); + const bool flipped = false; + const bool nearest_neighbor = false; TextureDrawQuad* quad = render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>(); - quad->SetNew(shared_state, - rect, - gfx::Rect(), - rect, - resource, - premultiplied_alpha, - gfx::PointF(0.0f, 0.0f), // uv_top_left - gfx::PointF(1.0f, 1.0f), // uv_bottom_right - background_color, - vertex_opacity, - false, // flipped - false); // nearest_neighbor + quad->SetNew(shared_state, rect, gfx::Rect(), rect, resource, + premultiplied_alpha, uv_top_left, uv_bottom_right, + background_color, vertex_opacity, flipped, nearest_neighbor); +} + +void CreateTestYUVVideoDrawQuad_FromVideoFrame( + const SharedQuadState* shared_state, + scoped_refptr<media::VideoFrame> video_frame, + uint8 alpha_value, + const gfx::RectF& tex_coord_rect, + RenderPass* render_pass, + VideoResourceUpdater* video_resource_updater, + const gfx::Rect& rect, + ResourceProvider* resource_provider) { + const bool with_alpha = (video_frame->format() == media::VideoFrame::YV12A); + const YUVVideoDrawQuad::ColorSpace color_space = + (video_frame->format() == media::VideoFrame::YV12J + ? YUVVideoDrawQuad::JPEG + : YUVVideoDrawQuad::REC_601); + const gfx::Rect opaque_rect(0, 0, 0, 0); + + if (with_alpha) { + memset(video_frame->data(media::VideoFrame::kAPlane), alpha_value, + video_frame->stride(media::VideoFrame::kAPlane) * + video_frame->rows(media::VideoFrame::kAPlane)); + } + + VideoFrameExternalResources resources = + video_resource_updater->CreateExternalResourcesFromVideoFrame( + video_frame); + + EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type); + EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()), + resources.mailboxes.size()); + EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()), + resources.release_callbacks.size()); + + ResourceProvider::ResourceId y_resource = + resource_provider->CreateResourceFromTextureMailbox( + resources.mailboxes[media::VideoFrame::kYPlane], + SingleReleaseCallbackImpl::Create( + resources.release_callbacks[media::VideoFrame::kYPlane])); + ResourceProvider::ResourceId u_resource = + resource_provider->CreateResourceFromTextureMailbox( + resources.mailboxes[media::VideoFrame::kUPlane], + SingleReleaseCallbackImpl::Create( + resources.release_callbacks[media::VideoFrame::kUPlane])); + ResourceProvider::ResourceId v_resource = + resource_provider->CreateResourceFromTextureMailbox( + resources.mailboxes[media::VideoFrame::kVPlane], + SingleReleaseCallbackImpl::Create( + resources.release_callbacks[media::VideoFrame::kVPlane])); + ResourceProvider::ResourceId a_resource = 0; + if (with_alpha) { + a_resource = resource_provider->CreateResourceFromTextureMailbox( + resources.mailboxes[media::VideoFrame::kAPlane], + SingleReleaseCallbackImpl::Create( + resources.release_callbacks[media::VideoFrame::kAPlane])); + } + + YUVVideoDrawQuad* yuv_quad = + render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>(); + yuv_quad->SetNew(shared_state, rect, opaque_rect, rect, tex_coord_rect, + video_frame->coded_size(), y_resource, u_resource, + v_resource, a_resource, color_space); +} + +void CreateTestYUVVideoDrawQuad_Striped( + const SharedQuadState* shared_state, + media::VideoFrame::Format format, + bool is_transparent, + const gfx::RectF& tex_coord_rect, + RenderPass* render_pass, + VideoResourceUpdater* video_resource_updater, + const gfx::Rect& rect, + ResourceProvider* resource_provider) { + scoped_refptr<media::VideoFrame> video_frame = media::VideoFrame::CreateFrame( + format, rect.size(), rect, rect.size(), base::TimeDelta()); + + // YUV values representing a striped pattern, for validating texture + // coordinates for sampling. + uint8_t y_value = 0; + uint8_t u_value = 0; + uint8_t v_value = 0; + for (int i = 0; i < video_frame->rows(media::VideoFrame::kYPlane); ++i) { + uint8_t* y_row = video_frame->data(media::VideoFrame::kYPlane) + + video_frame->stride(media::VideoFrame::kYPlane) * i; + for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kYPlane); + ++j) { + y_row[j] = (y_value += 1); + } + } + for (int i = 0; i < video_frame->rows(media::VideoFrame::kUPlane); ++i) { + uint8_t* u_row = video_frame->data(media::VideoFrame::kUPlane) + + video_frame->stride(media::VideoFrame::kUPlane) * i; + uint8_t* v_row = video_frame->data(media::VideoFrame::kVPlane) + + video_frame->stride(media::VideoFrame::kVPlane) * i; + for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kUPlane); + ++j) { + u_row[j] = (u_value += 3); + v_row[j] = (v_value += 5); + } + } + uint8 alpha_value = is_transparent ? 0 : 128; + CreateTestYUVVideoDrawQuad_FromVideoFrame( + shared_state, video_frame, alpha_value, tex_coord_rect, render_pass, + video_resource_updater, rect, resource_provider); +} + +// Creates a video frame of size background_size filled with yuv_background, +// and then draws a foreground rectangle in a different color on top of +// that. The foreground rectangle must have coordinates that are divisible +// by 2 because YUV is a block format. +void CreateTestYUVVideoDrawQuad_TwoColor( + const SharedQuadState* shared_state, + media::VideoFrame::Format format, + bool is_transparent, + const gfx::RectF& tex_coord_rect, + const gfx::Size& background_size, + uint8 y_background, + uint8 u_background, + uint8 v_background, + const gfx::Rect& foreground_rect, + uint8 y_foreground, + uint8 u_foreground, + uint8 v_foreground, + RenderPass* render_pass, + VideoResourceUpdater* video_resource_updater, + ResourceProvider* resource_provider) { + const gfx::Rect rect(background_size); + + scoped_refptr<media::VideoFrame> video_frame = + media::VideoFrame::CreateFrame(format, background_size, foreground_rect, + foreground_rect.size(), base::TimeDelta()); + + int planes[] = {media::VideoFrame::kYPlane, + media::VideoFrame::kUPlane, + media::VideoFrame::kVPlane}; + uint8 yuv_background[] = {y_background, u_background, v_background}; + uint8 yuv_foreground[] = {y_foreground, u_foreground, v_foreground}; + int sample_size[] = {1, 2, 2}; + + for (int i = 0; i < 3; ++i) { + memset(video_frame->data(planes[i]), yuv_background[i], + video_frame->stride(planes[i]) * video_frame->rows(planes[i])); + } + + for (int i = 0; i < 3; ++i) { + // Since yuv encoding uses block encoding, widths have to be divisible + // by the sample size in order for this function to behave properly. + DCHECK_EQ(foreground_rect.x() % sample_size[i], 0); + DCHECK_EQ(foreground_rect.y() % sample_size[i], 0); + DCHECK_EQ(foreground_rect.width() % sample_size[i], 0); + DCHECK_EQ(foreground_rect.height() % sample_size[i], 0); + + gfx::Rect sample_rect(foreground_rect.x() / sample_size[i], + foreground_rect.y() / sample_size[i], + foreground_rect.width() / sample_size[i], + foreground_rect.height() / sample_size[i]); + for (int y = sample_rect.y(); y < sample_rect.bottom(); ++y) { + for (int x = sample_rect.x(); x < sample_rect.right(); ++x) { + size_t offset = y * video_frame->stride(planes[i]) + x; + video_frame->data(planes[i])[offset] = yuv_foreground[i]; + } + } + } + + uint8 alpha_value = 255; + CreateTestYUVVideoDrawQuad_FromVideoFrame( + shared_state, video_frame, alpha_value, tex_coord_rect, render_pass, + video_resource_updater, rect, resource_provider); +} + +void CreateTestYUVVideoDrawQuad_Solid( + const SharedQuadState* shared_state, + media::VideoFrame::Format format, + bool is_transparent, + const gfx::RectF& tex_coord_rect, + uint8 y, + uint8 u, + uint8 v, + RenderPass* render_pass, + VideoResourceUpdater* video_resource_updater, + const gfx::Rect& rect, + ResourceProvider* resource_provider) { + scoped_refptr<media::VideoFrame> video_frame = media::VideoFrame::CreateFrame( + format, rect.size(), rect, rect.size(), base::TimeDelta()); + + // YUV values of a solid, constant, color. Useful for testing that color + // space/color range are being handled properly. + memset(video_frame->data(media::VideoFrame::kYPlane), y, + video_frame->stride(media::VideoFrame::kYPlane) * + video_frame->rows(media::VideoFrame::kYPlane)); + memset(video_frame->data(media::VideoFrame::kUPlane), u, + video_frame->stride(media::VideoFrame::kUPlane) * + video_frame->rows(media::VideoFrame::kUPlane)); + memset(video_frame->data(media::VideoFrame::kVPlane), v, + video_frame->stride(media::VideoFrame::kVPlane) * + video_frame->rows(media::VideoFrame::kVPlane)); + + uint8 alpha_value = is_transparent ? 0 : 128; + CreateTestYUVVideoDrawQuad_FromVideoFrame( + shared_state, video_frame, alpha_value, tex_coord_rect, render_pass, + video_resource_updater, rect, resource_provider); } typedef ::testing::Types<GLRenderer, @@ -323,6 +565,278 @@ TYPED_TEST(RendererPixelTest, PremultipliedTextureWithBackground) { FuzzyPixelOffByOneComparator(true))); } +template <typename QuadType> +static const base::FilePath::CharType* IntersectingQuadImage() { + return FILE_PATH_LITERAL("intersecting_blue_green_squares.png"); +} +template <> +const base::FilePath::CharType* IntersectingQuadImage<SolidColorDrawQuad>() { + return FILE_PATH_LITERAL("intersecting_blue_green.png"); +} +template <> +const base::FilePath::CharType* IntersectingQuadImage<YUVVideoDrawQuad>() { + return FILE_PATH_LITERAL("intersecting_blue_green_squares_video.png"); +} + +template <typename TypeParam> +class IntersectingQuadPixelTest : public RendererPixelTest<TypeParam> { + protected: + void SetupQuadStateAndRenderPass() { + // This sets up a pair of draw quads. They are both rotated + // relative to the root plane, they are also rotated relative to each other. + // The intersect in the middle at a non-perpendicular angle so that any + // errors are hopefully magnified. + // The quads should intersect correctly, as in the front quad should only + // be partially in front of the back quad, and partially behind. + + viewport_rect_ = gfx::Rect(this->device_viewport_size_); + quad_rect_ = gfx::Rect(0, 0, this->device_viewport_size_.width(), + this->device_viewport_size_.height() / 2.0); + + RenderPassId id(1, 1); + render_pass_ = CreateTestRootRenderPass(id, viewport_rect_); + + // Create the front quad rotated on the Z and Y axis. + gfx::Transform trans; + trans.Translate3d(0, 0, 0.707 * this->device_viewport_size_.width() / 2.0); + trans.RotateAboutZAxis(45.0); + trans.RotateAboutYAxis(45.0); + front_quad_state_ = + CreateTestSharedQuadState(trans, viewport_rect_, render_pass_.get()); + front_quad_state_->clip_rect = quad_rect_; + // Make sure they end up in a 3d sorting context. + front_quad_state_->sorting_context_id = 1; + + // Create the back quad, and rotate on just the y axis. This will intersect + // the first quad partially. + trans = gfx::Transform(); + trans.Translate3d(0, 0, -0.707 * this->device_viewport_size_.width() / 2.0); + trans.RotateAboutYAxis(-45.0); + back_quad_state_ = + CreateTestSharedQuadState(trans, viewport_rect_, render_pass_.get()); + back_quad_state_->sorting_context_id = 1; + back_quad_state_->clip_rect = quad_rect_; + } + template <typename T> + void AppendBackgroundAndRunTest(const PixelComparator& comparator) { + SharedQuadState* background_quad_state = CreateTestSharedQuadState( + gfx::Transform(), viewport_rect_, render_pass_.get()); + SolidColorDrawQuad* background_quad = + render_pass_->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); + background_quad->SetNew(background_quad_state, viewport_rect_, + viewport_rect_, SK_ColorWHITE, false); + pass_list_.push_back(render_pass_.Pass()); + const base::FilePath::CharType* fileName = IntersectingQuadImage<T>(); + EXPECT_TRUE( + this->RunPixelTest(&pass_list_, base::FilePath(fileName), comparator)); + } + template <typename T> + T* CreateAndAppendDrawQuad() { + return render_pass_->CreateAndAppendDrawQuad<T>(); + } + + scoped_ptr<RenderPass> render_pass_; + gfx::Rect viewport_rect_; + SharedQuadState* front_quad_state_; + SharedQuadState* back_quad_state_; + gfx::Rect quad_rect_; + RenderPassList pass_list_; +}; + +template <typename TypeParam> +class IntersectingQuadGLPixelTest + : public IntersectingQuadPixelTest<TypeParam> { + public: + void SetUp() override { + IntersectingQuadPixelTest<TypeParam>::SetUp(); + video_resource_updater_.reset( + new VideoResourceUpdater(this->output_surface_->context_provider(), + this->resource_provider_.get())); + video_resource_updater2_.reset( + new VideoResourceUpdater(this->output_surface_->context_provider(), + this->resource_provider_.get())); + } + + protected: + scoped_ptr<VideoResourceUpdater> video_resource_updater_; + scoped_ptr<VideoResourceUpdater> video_resource_updater2_; +}; + +template <typename TypeParam> +class IntersectingQuadSoftwareTest + : public IntersectingQuadPixelTest<TypeParam> {}; + +typedef ::testing::Types<SoftwareRenderer, SoftwareRendererWithExpandedViewport> + SoftwareRendererTypes; +typedef ::testing::Types<GLRenderer, GLRendererWithExpandedViewport> + GLRendererTypes; + +TYPED_TEST_CASE(IntersectingQuadPixelTest, RendererTypes); +TYPED_TEST_CASE(IntersectingQuadGLPixelTest, GLRendererTypes); +TYPED_TEST_CASE(IntersectingQuadSoftwareTest, SoftwareRendererTypes); + +TYPED_TEST(IntersectingQuadPixelTest, SolidColorQuads) { + this->SetupQuadStateAndRenderPass(); + + SolidColorDrawQuad* quad = + this->template CreateAndAppendDrawQuad<SolidColorDrawQuad>(); + SolidColorDrawQuad* quad2 = + this->template CreateAndAppendDrawQuad<SolidColorDrawQuad>(); + + quad->SetNew(this->front_quad_state_, this->quad_rect_, this->quad_rect_, + SK_ColorBLUE, false); + quad2->SetNew(this->back_quad_state_, this->quad_rect_, this->quad_rect_, + SK_ColorGREEN, false); + SCOPED_TRACE("IntersectingSolidColorQuads"); + this->template AppendBackgroundAndRunTest<SolidColorDrawQuad>( + FuzzyPixelComparator(false, 2.f, 0.f, 256.f, 256, 0.f)); +} + +template <typename TypeParam> +SkColor GetColor(const SkColor& color) { + return color; +} + +template <> +SkColor GetColor<GLRenderer>(const SkColor& color) { + return SkColorSetARGB(SkColorGetA(color), SkColorGetB(color), + SkColorGetG(color), SkColorGetR(color)); +} +template <> +SkColor GetColor<GLRendererWithExpandedViewport>(const SkColor& color) { + return GetColor<GLRenderer>(color); +} + +TYPED_TEST(IntersectingQuadPixelTest, TexturedQuads) { + this->SetupQuadStateAndRenderPass(); + CreateTestTwoColoredTextureDrawQuad( + this->quad_rect_, GetColor<TypeParam>(SkColorSetARGB(255, 0, 0, 0)), + GetColor<TypeParam>(SkColorSetARGB(255, 0, 0, 255)), SK_ColorTRANSPARENT, + true, this->front_quad_state_, this->resource_provider_.get(), + this->render_pass_.get()); + CreateTestTwoColoredTextureDrawQuad( + this->quad_rect_, GetColor<TypeParam>(SkColorSetARGB(255, 0, 255, 0)), + GetColor<TypeParam>(SkColorSetARGB(255, 0, 0, 0)), SK_ColorTRANSPARENT, + true, this->back_quad_state_, this->resource_provider_.get(), + this->render_pass_.get()); + + SCOPED_TRACE("IntersectingTexturedQuads"); + this->template AppendBackgroundAndRunTest<TextureDrawQuad>( + FuzzyPixelComparator(false, 2.f, 0.f, 256.f, 256, 0.f)); +} + +TYPED_TEST(IntersectingQuadSoftwareTest, PictureQuads) { + this->SetupQuadStateAndRenderPass(); + gfx::RectF outer_rect(this->quad_rect_); + gfx::RectF inner_rect(this->quad_rect_.x() + (this->quad_rect_.width() / 4), + this->quad_rect_.y() + (this->quad_rect_.height() / 4), + this->quad_rect_.width() / 2, + this->quad_rect_.height() / 2); + + SkPaint black_paint; + black_paint.setColor(SK_ColorBLACK); + SkPaint blue_paint; + blue_paint.setColor(SK_ColorBLUE); + SkPaint green_paint; + green_paint.setColor(SK_ColorGREEN); + + scoped_ptr<FakePicturePile> blue_recording = + FakePicturePile::CreateFilledPile(gfx::Size(1000, 1000), + this->quad_rect_.size()); + blue_recording->add_draw_rect_with_paint(outer_rect, black_paint); + blue_recording->add_draw_rect_with_paint(inner_rect, blue_paint); + blue_recording->RerecordPile(); + scoped_refptr<FakePicturePileImpl> blue_pile = + FakePicturePileImpl::CreateFromPile(blue_recording.get(), nullptr); + + PictureDrawQuad* blue_quad = + this->render_pass_->template CreateAndAppendDrawQuad<PictureDrawQuad>(); + + blue_quad->SetNew(this->front_quad_state_, this->quad_rect_, gfx::Rect(), + this->quad_rect_, this->quad_rect_, this->quad_rect_.size(), + false, RGBA_8888, this->quad_rect_, 1.f, blue_pile); + + scoped_ptr<FakePicturePile> green_recording = + FakePicturePile::CreateFilledPile(this->quad_rect_.size(), + this->quad_rect_.size()); + green_recording->add_draw_rect_with_paint(outer_rect, green_paint); + green_recording->add_draw_rect_with_paint(inner_rect, black_paint); + green_recording->RerecordPile(); + scoped_refptr<FakePicturePileImpl> green_pile = + FakePicturePileImpl::CreateFromPile(green_recording.get(), nullptr); + + PictureDrawQuad* green_quad = + this->render_pass_->template CreateAndAppendDrawQuad<PictureDrawQuad>(); + green_quad->SetNew(this->back_quad_state_, this->quad_rect_, gfx::Rect(), + this->quad_rect_, this->quad_rect_, + this->quad_rect_.size(), false, RGBA_8888, + this->quad_rect_, 1.f, green_pile); + SCOPED_TRACE("IntersectingPictureQuadsPass"); + this->template AppendBackgroundAndRunTest<PictureDrawQuad>( + FuzzyPixelComparator(false, 2.f, 0.f, 256.f, 256, 0.f)); +} + +TYPED_TEST(IntersectingQuadPixelTest, RenderPassQuads) { + this->SetupQuadStateAndRenderPass(); + RenderPassId child_pass_id1(2, 2); + RenderPassId child_pass_id2(2, 3); + scoped_ptr<RenderPass> child_pass1 = + CreateTestRenderPass(child_pass_id1, this->quad_rect_, gfx::Transform()); + SharedQuadState* child1_quad_state = CreateTestSharedQuadState( + gfx::Transform(), this->quad_rect_, child_pass1.get()); + scoped_ptr<RenderPass> child_pass2 = + CreateTestRenderPass(child_pass_id2, this->quad_rect_, gfx::Transform()); + SharedQuadState* child2_quad_state = CreateTestSharedQuadState( + gfx::Transform(), this->quad_rect_, child_pass2.get()); + + CreateTestTwoColoredTextureDrawQuad( + this->quad_rect_, GetColor<TypeParam>(SkColorSetARGB(255, 0, 0, 0)), + GetColor<TypeParam>(SkColorSetARGB(255, 0, 0, 255)), SK_ColorTRANSPARENT, + true, child1_quad_state, this->resource_provider_.get(), + child_pass1.get()); + CreateTestTwoColoredTextureDrawQuad( + this->quad_rect_, GetColor<TypeParam>(SkColorSetARGB(255, 0, 255, 0)), + GetColor<TypeParam>(SkColorSetARGB(255, 0, 0, 0)), SK_ColorTRANSPARENT, + true, child2_quad_state, this->resource_provider_.get(), + child_pass2.get()); + + CreateTestRenderPassDrawQuad(this->front_quad_state_, this->quad_rect_, + child_pass_id1, this->render_pass_.get()); + CreateTestRenderPassDrawQuad(this->back_quad_state_, this->quad_rect_, + child_pass_id2, this->render_pass_.get()); + + this->pass_list_.push_back(child_pass1.Pass()); + this->pass_list_.push_back(child_pass2.Pass()); + SCOPED_TRACE("IntersectingRenderQuadsPass"); + this->template AppendBackgroundAndRunTest<RenderPassDrawQuad>( + FuzzyPixelComparator(false, 2.f, 0.f, 256.f, 256, 0.f)); +} + +TYPED_TEST(IntersectingQuadGLPixelTest, YUVVideoQuads) { + this->SetupQuadStateAndRenderPass(); + gfx::Rect inner_rect( + ((this->quad_rect_.x() + (this->quad_rect_.width() / 4)) & ~0xF), + ((this->quad_rect_.y() + (this->quad_rect_.height() / 4)) & ~0xF), + (this->quad_rect_.width() / 2) & ~0xF, + (this->quad_rect_.height() / 2) & ~0xF); + + CreateTestYUVVideoDrawQuad_TwoColor( + this->front_quad_state_, media::VideoFrame::YV12J, false, + gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), this->quad_rect_.size(), 0, 128, 128, + inner_rect, 29, 255, 107, this->render_pass_.get(), + this->video_resource_updater_.get(), this->resource_provider_.get()); + + CreateTestYUVVideoDrawQuad_TwoColor( + this->back_quad_state_, media::VideoFrame::YV12J, false, + gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), this->quad_rect_.size(), 149, 43, 21, + inner_rect, 0, 128, 128, this->render_pass_.get(), + this->video_resource_updater2_.get(), this->resource_provider_.get()); + + SCOPED_TRACE("IntersectingVideoQuads"); + this->template AppendBackgroundAndRunTest<YUVVideoDrawQuad>( + FuzzyPixelOffByOneComparator(false)); +} + // TODO(skaslev): The software renderer does not support non-premultplied alpha. TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithoutBackground) { gfx::Rect rect(this->device_viewport_size_); @@ -390,80 +904,6 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBackground) { class VideoGLRendererPixelTest : public GLRendererPixelTest { protected: - void CreateTestYUVVideoDrawQuad_Striped(const SharedQuadState* shared_state, - media::VideoFrame::Format format, - bool is_transparent, - const gfx::RectF& tex_coord_rect, - RenderPass* render_pass) { - const gfx::Rect rect(this->device_viewport_size_); - - scoped_refptr<media::VideoFrame> video_frame = - media::VideoFrame::CreateFrame( - format, rect.size(), rect, rect.size(), base::TimeDelta()); - - // YUV values representing a striped pattern, for validating texture - // coordinates for sampling. - uint8_t y_value = 0; - uint8_t u_value = 0; - uint8_t v_value = 0; - for (int i = 0; i < video_frame->rows(media::VideoFrame::kYPlane); ++i) { - uint8_t* y_row = video_frame->data(media::VideoFrame::kYPlane) + - video_frame->stride(media::VideoFrame::kYPlane) * i; - for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kYPlane); - ++j) { - y_row[j] = (y_value += 1); - } - } - for (int i = 0; i < video_frame->rows(media::VideoFrame::kUPlane); ++i) { - uint8_t* u_row = video_frame->data(media::VideoFrame::kUPlane) + - video_frame->stride(media::VideoFrame::kUPlane) * i; - uint8_t* v_row = video_frame->data(media::VideoFrame::kVPlane) + - video_frame->stride(media::VideoFrame::kVPlane) * i; - for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kUPlane); - ++j) { - u_row[j] = (u_value += 3); - v_row[j] = (v_value += 5); - } - } - uint8 alpha_value = is_transparent ? 0 : 128; - CreateTestYUVVideoDrawQuad_FromVideoFrame( - shared_state, video_frame, alpha_value, tex_coord_rect, render_pass); - } - - void CreateTestYUVVideoDrawQuad_Solid(const SharedQuadState* shared_state, - media::VideoFrame::Format format, - bool is_transparent, - const gfx::RectF& tex_coord_rect, - uint8 y, - uint8 u, - uint8 v, - RenderPass* render_pass) { - const gfx::Rect rect(this->device_viewport_size_); - - scoped_refptr<media::VideoFrame> video_frame = - media::VideoFrame::CreateFrame( - format, rect.size(), rect, rect.size(), base::TimeDelta()); - - // YUV values of a solid, constant, color. Useful for testing that color - // space/color range are being handled properly. - memset(video_frame->data(media::VideoFrame::kYPlane), - y, - video_frame->stride(media::VideoFrame::kYPlane) * - video_frame->rows(media::VideoFrame::kYPlane)); - memset(video_frame->data(media::VideoFrame::kUPlane), - u, - video_frame->stride(media::VideoFrame::kUPlane) * - video_frame->rows(media::VideoFrame::kUPlane)); - memset(video_frame->data(media::VideoFrame::kVPlane), - v, - video_frame->stride(media::VideoFrame::kVPlane) * - video_frame->rows(media::VideoFrame::kVPlane)); - - uint8 alpha_value = is_transparent ? 0 : 128; - CreateTestYUVVideoDrawQuad_FromVideoFrame( - shared_state, video_frame, alpha_value, tex_coord_rect, render_pass); - } - void CreateEdgeBleedPass(media::VideoFrame::Format format, RenderPassList* pass_list) { gfx::Rect rect(200, 200); @@ -492,139 +932,19 @@ class VideoGLRendererPixelTest : public GLRendererPixelTest { // green sub-rectangle that should be the only thing displayed in // the final image. Bleeding will appear on all four sides of the video // if the tex coords are not clamped. - CreateTestYUVVideoDrawQuad_TwoColor(shared_state, format, false, - tex_coord_rect, background_size, 0, 0, - 0, green_rect, 149, 43, 21, pass.get()); + CreateTestYUVVideoDrawQuad_TwoColor( + shared_state, format, false, tex_coord_rect, background_size, 0, 0, 0, + green_rect, 149, 43, 21, pass.get(), video_resource_updater_.get(), + resource_provider_.get()); pass_list->push_back(pass.Pass()); } - // Creates a video frame of size background_size filled with yuv_background, - // and then draws a foreground rectangle in a different color on top of - // that. The foreground rectangle must have coordinates that are divisible - // by 2 because YUV is a block format. - void CreateTestYUVVideoDrawQuad_TwoColor(const SharedQuadState* shared_state, - media::VideoFrame::Format format, - bool is_transparent, - const gfx::RectF& tex_coord_rect, - const gfx::Size& background_size, - uint8 y_background, - uint8 u_background, - uint8 v_background, - const gfx::Rect& foreground_rect, - uint8 y_foreground, - uint8 u_foreground, - uint8 v_foreground, - RenderPass* render_pass) { - const gfx::Rect rect(background_size); - - scoped_refptr<media::VideoFrame> video_frame = - media::VideoFrame::CreateFrame(format, background_size, foreground_rect, - foreground_rect.size(), - base::TimeDelta()); - - int planes[] = {media::VideoFrame::kYPlane, - media::VideoFrame::kUPlane, - media::VideoFrame::kVPlane}; - uint8 yuv_background[] = {y_background, u_background, v_background}; - uint8 yuv_foreground[] = {y_foreground, u_foreground, v_foreground}; - int sample_size[] = {1, 2, 2}; - - for (int i = 0; i < 3; ++i) { - memset(video_frame->data(planes[i]), yuv_background[i], - video_frame->stride(planes[i]) * video_frame->rows(planes[i])); - } - - for (int i = 0; i < 3; ++i) { - // Since yuv encoding uses block encoding, widths have to be divisible - // by the sample size in order for this function to behave properly. - DCHECK_EQ(foreground_rect.x() % sample_size[i], 0); - DCHECK_EQ(foreground_rect.y() % sample_size[i], 0); - DCHECK_EQ(foreground_rect.width() % sample_size[i], 0); - DCHECK_EQ(foreground_rect.height() % sample_size[i], 0); - - gfx::Rect sample_rect(foreground_rect.x() / sample_size[i], - foreground_rect.y() / sample_size[i], - foreground_rect.width() / sample_size[i], - foreground_rect.height() / sample_size[i]); - for (int y = sample_rect.y(); y < sample_rect.bottom(); ++y) { - for (int x = sample_rect.x(); x < sample_rect.right(); ++x) { - size_t offset = y * video_frame->stride(planes[i]) + x; - video_frame->data(planes[i])[offset] = yuv_foreground[i]; - } - } - } - - uint8 alpha_value = 255; - CreateTestYUVVideoDrawQuad_FromVideoFrame( - shared_state, video_frame, alpha_value, tex_coord_rect, render_pass); - } - - void CreateTestYUVVideoDrawQuad_FromVideoFrame( - const SharedQuadState* shared_state, - scoped_refptr<media::VideoFrame> video_frame, - uint8 alpha_value, - const gfx::RectF& tex_coord_rect, - RenderPass* render_pass) { - const bool with_alpha = (video_frame->format() == media::VideoFrame::YV12A); - const YUVVideoDrawQuad::ColorSpace color_space = - (video_frame->format() == media::VideoFrame::YV12J - ? YUVVideoDrawQuad::JPEG - : YUVVideoDrawQuad::REC_601); - const gfx::Rect rect(shared_state->content_bounds); - const gfx::Rect opaque_rect(0, 0, 0, 0); - - if (with_alpha) - memset(video_frame->data(media::VideoFrame::kAPlane), alpha_value, - video_frame->stride(media::VideoFrame::kAPlane) * - video_frame->rows(media::VideoFrame::kAPlane)); - - VideoFrameExternalResources resources = - video_resource_updater_->CreateExternalResourcesFromVideoFrame( - video_frame); - - EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type); - EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()), - resources.mailboxes.size()); - EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()), - resources.release_callbacks.size()); - - ResourceProvider::ResourceId y_resource = - resource_provider_->CreateResourceFromTextureMailbox( - resources.mailboxes[media::VideoFrame::kYPlane], - SingleReleaseCallbackImpl::Create( - resources.release_callbacks[media::VideoFrame::kYPlane])); - ResourceProvider::ResourceId u_resource = - resource_provider_->CreateResourceFromTextureMailbox( - resources.mailboxes[media::VideoFrame::kUPlane], - SingleReleaseCallbackImpl::Create( - resources.release_callbacks[media::VideoFrame::kUPlane])); - ResourceProvider::ResourceId v_resource = - resource_provider_->CreateResourceFromTextureMailbox( - resources.mailboxes[media::VideoFrame::kVPlane], - SingleReleaseCallbackImpl::Create( - resources.release_callbacks[media::VideoFrame::kVPlane])); - ResourceProvider::ResourceId a_resource = 0; - if (with_alpha) { - a_resource = resource_provider_->CreateResourceFromTextureMailbox( - resources.mailboxes[media::VideoFrame::kAPlane], - SingleReleaseCallbackImpl::Create( - resources.release_callbacks[media::VideoFrame::kAPlane])); - } - - YUVVideoDrawQuad* yuv_quad = - render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>(); - yuv_quad->SetNew(shared_state, rect, opaque_rect, rect, tex_coord_rect, - video_frame->coded_size(), y_resource, u_resource, - v_resource, a_resource, color_space); - } - void SetUp() override { GLRendererPixelTest::SetUp(); video_resource_updater_.reset(new VideoResourceUpdater( output_surface_->context_provider(), resource_provider_.get())); } - private: scoped_ptr<VideoResourceUpdater> video_resource_updater_; }; @@ -637,11 +957,10 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) { SharedQuadState* shared_state = CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); - CreateTestYUVVideoDrawQuad_Striped(shared_state, - media::VideoFrame::YV12, - false, - gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), - pass.get()); + CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12, + false, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), + pass.get(), video_resource_updater_.get(), + rect, resource_provider_.get()); RenderPassList pass_list; pass_list.push_back(pass.Pass()); @@ -662,11 +981,10 @@ TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) { CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); // Intentionally sets frame format to I420 for testing coverage. - CreateTestYUVVideoDrawQuad_Striped(shared_state, - media::VideoFrame::I420, - false, - gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f), - pass.get()); + CreateTestYUVVideoDrawQuad_Striped( + shared_state, media::VideoFrame::I420, false, + gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f), pass.get(), + video_resource_updater_.get(), rect, resource_provider_.get()); RenderPassList pass_list; pass_list.push_back(pass.Pass()); @@ -687,14 +1005,10 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVRectBlack) { CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); // In MPEG color range YUV values of (15,128,128) should produce black. - CreateTestYUVVideoDrawQuad_Solid(shared_state, - media::VideoFrame::YV12, - false, - gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), - 15, - 128, - 128, - pass.get()); + CreateTestYUVVideoDrawQuad_Solid( + shared_state, media::VideoFrame::YV12, false, + gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 15, 128, 128, pass.get(), + video_resource_updater_.get(), rect, resource_provider_.get()); RenderPassList pass_list; pass_list.push_back(pass.Pass()); @@ -716,14 +1030,10 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) { CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); // YUV of (149,43,21) should be green (0,255,0) in RGB. - CreateTestYUVVideoDrawQuad_Solid(shared_state, - media::VideoFrame::YV12J, - false, - gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), - 149, - 43, - 21, - pass.get()); + CreateTestYUVVideoDrawQuad_Solid( + shared_state, media::VideoFrame::YV12J, false, + gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 149, 43, 21, pass.get(), + video_resource_updater_.get(), rect, resource_provider_.get()); RenderPassList pass_list; pass_list.push_back(pass.Pass()); @@ -761,14 +1071,10 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVJRectGrey) { CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); // Dark grey in JPEG color range (in MPEG, this is black). - CreateTestYUVVideoDrawQuad_Solid(shared_state, - media::VideoFrame::YV12J, - false, - gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), - 15, - 128, - 128, - pass.get()); + CreateTestYUVVideoDrawQuad_Solid( + shared_state, media::VideoFrame::YV12J, false, + gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 15, 128, 128, pass.get(), + video_resource_updater_.get(), rect, resource_provider_.get()); RenderPassList pass_list; pass_list.push_back(pass.Pass()); @@ -788,11 +1094,10 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) { SharedQuadState* shared_state = CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); - CreateTestYUVVideoDrawQuad_Striped(shared_state, - media::VideoFrame::YV12A, - false, - gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), - pass.get()); + CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12A, + false, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), + pass.get(), video_resource_updater_.get(), + rect, resource_provider_.get()); SolidColorDrawQuad* color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); @@ -816,11 +1121,10 @@ TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) { SharedQuadState* shared_state = CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); - CreateTestYUVVideoDrawQuad_Striped(shared_state, - media::VideoFrame::YV12A, - true, - gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), - pass.get()); + CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12A, + true, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), + pass.get(), video_resource_updater_.get(), + rect, resource_provider_.get()); SolidColorDrawQuad* color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc index a4b5428..19c4fa3 100644 --- a/cc/output/software_renderer.cc +++ b/cc/output/software_renderer.cc @@ -25,6 +25,7 @@ #include "third_party/skia/include/core/SkColor.h" #include "third_party/skia/include/core/SkImageFilter.h" #include "third_party/skia/include/core/SkMatrix.h" +#include "third_party/skia/include/core/SkPoint.h" #include "third_party/skia/include/core/SkShader.h" #include "third_party/skia/include/effects/SkLayerRasterizer.h" #include "ui/gfx/geometry/rect_conversions.h" @@ -235,7 +236,13 @@ bool SoftwareRenderer::IsSoftwareResource( return false; } -void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) { +void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame, + const DrawQuad* quad, + const gfx::QuadF* draw_region) { + if (draw_region) { + current_canvas_->save(); + } + TRACE_EVENT0("cc", "SoftwareRenderer::DoDrawQuad"); gfx::Transform quad_rect_matrix; QuadRectTransform(&quad_rect_matrix, quad->quadTransform(), quad->rect); @@ -270,9 +277,31 @@ void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) { current_paint_.setXfermodeMode(SkXfermode::kSrc_Mode); } + if (draw_region) { + gfx::QuadF local_draw_region(*draw_region); + SkPath draw_region_clip_path; + local_draw_region -= + gfx::Vector2dF(quad->visible_rect.x(), quad->visible_rect.y()); + local_draw_region.Scale(1.0f / quad->visible_rect.width(), + 1.0f / quad->visible_rect.height()); + local_draw_region -= gfx::Vector2dF(0.5f, 0.5f); + + SkPoint clip_points[4]; + QuadFToSkPoints(local_draw_region, clip_points); + draw_region_clip_path.addPoly(clip_points, 4, true); + + current_canvas_->clipPath(draw_region_clip_path, SkRegion::kIntersect_Op, + false); + } + switch (quad->material) { case DrawQuad::CHECKERBOARD: - DrawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad)); + // TODO(enne) For now since checkerboards shouldn't be part of a 3D + // context, clipping regions aren't supported so we skip drawing them + // if this becomes the case. + if (!draw_region) { + DrawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad)); + } break; case DrawQuad::DEBUG_BORDER: DrawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad)); @@ -307,6 +336,9 @@ void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) { } current_canvas_->resetMatrix(); + if (draw_region) { + current_canvas_->restore(); + } } void SoftwareRenderer::DrawCheckerboardQuad(const DrawingFrame* frame, diff --git a/cc/output/software_renderer.h b/cc/output/software_renderer.h index 99868c3..dc8e2fb 100644 --- a/cc/output/software_renderer.h +++ b/cc/output/software_renderer.h @@ -52,7 +52,10 @@ class CC_EXPORT SoftwareRenderer : public DirectRenderer { bool draw_rect_covers_full_surface) override; void ClearFramebuffer(DrawingFrame* frame, bool has_external_stencil_test) override; - void DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) override; + + void DoDrawQuad(DrawingFrame* frame, + const DrawQuad* quad, + const gfx::QuadF* draw_region) override; void BeginDrawingFrame(DrawingFrame* frame) override; void FinishDrawingFrame(DrawingFrame* frame) override; bool FlippedFramebuffer(const DrawingFrame* frame) const override; diff --git a/cc/output/static_geometry_binding.cc b/cc/output/static_geometry_binding.cc new file mode 100644 index 0000000..683db2d --- /dev/null +++ b/cc/output/static_geometry_binding.cc @@ -0,0 +1,72 @@ +// Copyright 2015 The Chromium 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 "cc/output/static_geometry_binding.h" + +#include "cc/output/gl_renderer.h" // For the GLC() macro. +#include "gpu/command_buffer/client/gles2_interface.h" +#include "ui/gfx/geometry/rect_f.h" + +namespace cc { + +StaticGeometryBinding::StaticGeometryBinding(gpu::gles2::GLES2Interface* gl, + const gfx::RectF& quad_vertex_rect) + : gl_(gl), quad_vertices_vbo_(0), quad_elements_vbo_(0) { + GeometryBindingQuad quads[8]; + GeometryBindingQuadIndex quad_indices[8]; + + static_assert(sizeof(GeometryBindingQuad) == 24 * sizeof(float), + "struct Quad should be densely packed"); + static_assert(sizeof(GeometryBindingQuadIndex) == 6 * sizeof(uint16_t), + "struct QuadIndex should be densely packed"); + + for (size_t i = 0; i < 8; i++) { + GeometryBindingVertex v0 = { + {quad_vertex_rect.x(), quad_vertex_rect.bottom(), 0.0f}, + {0.0f, 1.0f}, + i * 4.0f + 0.0f}; + GeometryBindingVertex v1 = { + {quad_vertex_rect.x(), quad_vertex_rect.y(), 0.0f}, + {0.0f, 0.0f}, + i * 4.0f + 1.0f}; + GeometryBindingVertex v2 = { + {quad_vertex_rect.right(), quad_vertex_rect.y(), 0.0f}, + {1.0f, 0.0f}, + i * 4.0f + 2.0f}; + GeometryBindingVertex v3 = { + {quad_vertex_rect.right(), quad_vertex_rect.bottom(), 0.0f}, + {1.0f, 1.0f}, + i * 4.0f + 3.0f}; + GeometryBindingQuad x(v0, v1, v2, v3); + quads[i] = x; + GeometryBindingQuadIndex y( + static_cast<uint16>(0 + 4 * i), static_cast<uint16>(1 + 4 * i), + static_cast<uint16>(2 + 4 * i), static_cast<uint16>(3 + 4 * i), + static_cast<uint16>(0 + 4 * i), static_cast<uint16>(2 + 4 * i)); + quad_indices[i] = y; + } + + GLC(gl_, gl_->GenBuffers(1, &quad_vertices_vbo_)); + GLC(gl_, gl_->GenBuffers(1, &quad_elements_vbo_)); + + GLC(gl_, gl_->BindBuffer(GL_ARRAY_BUFFER, quad_vertices_vbo_)); + GLC(gl_, gl_->BufferData(GL_ARRAY_BUFFER, sizeof(GeometryBindingQuad) * 8, + quads, GL_STATIC_DRAW)); + + GLC(gl_, gl_->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, quad_elements_vbo_)); + GLC(gl_, gl_->BufferData(GL_ELEMENT_ARRAY_BUFFER, + sizeof(GeometryBindingQuadIndex) * 8, &quad_indices, + GL_STATIC_DRAW)); +} + +StaticGeometryBinding::~StaticGeometryBinding() { + gl_->DeleteBuffers(1, &quad_vertices_vbo_); + gl_->DeleteBuffers(1, &quad_elements_vbo_); +} + +void StaticGeometryBinding::PrepareForDraw() { + SetupGLContext(gl_, quad_elements_vbo_, quad_vertices_vbo_); +} + +} // namespace cc diff --git a/cc/output/static_geometry_binding.h b/cc/output/static_geometry_binding.h new file mode 100644 index 0000000..bd6bfcc --- /dev/null +++ b/cc/output/static_geometry_binding.h @@ -0,0 +1,33 @@ +// Copyright 2015 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CC_OUTPUT_STATIC_GEOMETRY_BINDING_H_ +#define CC_OUTPUT_STATIC_GEOMETRY_BINDING_H_ + +#include "cc/output/geometry_binding.h" + +using gpu::gles2::GLES2Interface; + +namespace cc { + +class StaticGeometryBinding { + public: + StaticGeometryBinding(gpu::gles2::GLES2Interface* gl, + const gfx::RectF& quad_vertex_rect); + ~StaticGeometryBinding(); + + void PrepareForDraw(); + + private: + gpu::gles2::GLES2Interface* gl_; + + GLuint quad_vertices_vbo_; + GLuint quad_elements_vbo_; + + DISALLOW_COPY_AND_ASSIGN(StaticGeometryBinding); +}; + +} // namespace cc + +#endif // CC_OUTPUT_STATIC_GEOMETRY_BINDING_H_ diff --git a/cc/quads/draw_polygon.cc b/cc/quads/draw_polygon.cc index 026be2c..6544b64 100644 --- a/cc/quads/draw_polygon.cc +++ b/cc/quads/draw_polygon.cc @@ -12,7 +12,7 @@ namespace { // This allows for some imperfection in the normal comparison when checking if // two pieces of geometry are coplanar. -static const float coplanar_dot_epsilon = 0.01f; +static const float coplanar_dot_epsilon = 0.001f; // This threshold controls how "thick" a plane is. If a point's distance is // <= |compare_threshold|, then it is considered on the plane. Only when this // boundary is crossed do we consider doing splitting. @@ -25,21 +25,23 @@ static const float compare_threshold = 1.0f; // points that SHOULD be intersecting the "thick plane", but actually fail to // test positively for it because |split_threshold| allowed them to be outside // this range. +// This is really supposd to be compare_threshold / 2.0f, but that would +// create another static initializer. static const float split_threshold = 0.5f; + +static const float normalized_threshold = 0.001f; } // namespace namespace cc { -gfx::Vector3dF DrawPolygon::default_normal = gfx::Vector3dF(0.0f, 0.0f, -1.0f); - DrawPolygon::DrawPolygon() { } -DrawPolygon::DrawPolygon(DrawQuad* original, +DrawPolygon::DrawPolygon(const DrawQuad* original, const std::vector<gfx::Point3F>& in_points, const gfx::Vector3dF& normal, int draw_order_index) - : order_index_(draw_order_index), original_ref_(original) { + : order_index_(draw_order_index), original_ref_(original), is_split_(true) { for (size_t i = 0; i < in_points.size(); i++) { points_.push_back(in_points[i]); } @@ -49,12 +51,14 @@ DrawPolygon::DrawPolygon(DrawQuad* original, // This takes the original DrawQuad that this polygon should be based on, // a visible content rect to make the 4 corner points from, and a transformation // to move it and its normal into screen space. -DrawPolygon::DrawPolygon(DrawQuad* original_ref, +DrawPolygon::DrawPolygon(const DrawQuad* original_ref, const gfx::RectF& visible_content_rect, const gfx::Transform& transform, int draw_order_index) - : order_index_(draw_order_index), original_ref_(original_ref) { - normal_ = default_normal; + : normal_(0.0f, 0.0f, 1.0f), + order_index_(draw_order_index), + original_ref_(original_ref), + is_split_(false) { gfx::Point3F points[8]; int num_vertices_in_clipped_quad; gfx::QuadF send_quad(visible_content_rect); @@ -97,6 +101,9 @@ float DrawPolygon::SignedPointDistance(const gfx::Point3F& point) const { // Assumes that layers are split and there are no intersecting planes. BspCompareResult DrawPolygon::SideCompare(const DrawPolygon& a, const DrawPolygon& b) { + // Let's make sure that both of these are normalized. + DCHECK_GE(normalized_threshold, std::abs(a.normal_.LengthSquared() - 1.0f)); + DCHECK_GE(normalized_threshold, std::abs(b.normal_.LengthSquared() - 1.0f)); // Right away let's check if they're coplanar double dot = gfx::DotProduct(a.normal_, b.normal_); float sign = 0.0f; @@ -105,7 +112,7 @@ BspCompareResult DrawPolygon::SideCompare(const DrawPolygon& a, if (std::abs(dot) >= 1.0f - coplanar_dot_epsilon) { normal_match = true; // The normals are matching enough that we only have to test one point. - sign = gfx::DotProduct(a.points_[0] - b.points_[0], b.normal_); + sign = b.SignedPointDistance(a.points_[0]); // Is it on either side of the splitter? if (sign < -compare_threshold) { return BSP_BACK; @@ -168,7 +175,7 @@ static bool LineIntersectPlane(const gfx::Point3F& line_start, // The case where one vertex lies on the thick-plane and the other // is outside of it. - if (std::abs(start_distance) < distance_threshold && + if (std::abs(start_distance) <= distance_threshold && std::abs(end_distance) > distance_threshold) { intersection->SetPoint(line_start.x(), line_start.y(), line_start.z()); return true; @@ -270,7 +277,7 @@ bool DrawPolygon::Split(const DrawPolygon& splitter, break; } } - if (current_vertex++ > points_size) { + if (current_vertex++ > (points_size)) { break; } } @@ -284,6 +291,7 @@ bool DrawPolygon::Split(const DrawPolygon& splitter, // First polygon. out_points[0].push_back(intersections[0]); + DCHECK_GE(vertex_before[1], start1); for (size_t i = start1; i <= vertex_before[1]; i++) { out_points[0].push_back(points_[i]); --points_remaining; @@ -306,6 +314,9 @@ bool DrawPolygon::Split(const DrawPolygon& splitter, scoped_ptr<DrawPolygon> poly2( new DrawPolygon(original_ref_, out_points[1], normal_, order_index_)); + DCHECK_GE(poly1->points().size(), 3u); + DCHECK_GE(poly2->points().size(), 3u); + if (SideCompare(*poly1, splitter) == BSP_FRONT) { *front = poly1.Pass(); *back = poly2.Pass(); diff --git a/cc/quads/draw_polygon.h b/cc/quads/draw_polygon.h index 32643ee..b94ff1e 100644 --- a/cc/quads/draw_polygon.h +++ b/cc/quads/draw_polygon.h @@ -24,11 +24,11 @@ class CC_EXPORT DrawPolygon { DrawPolygon(); ~DrawPolygon(); - DrawPolygon(DrawQuad* original_ref, + DrawPolygon(const DrawQuad* original_ref, const std::vector<gfx::Point3F>& in_points, const gfx::Vector3dF& normal, int draw_order_index = 0); - DrawPolygon(DrawQuad* original_ref, + DrawPolygon(const DrawQuad* original_ref, const gfx::RectF& visible_content_rect, const gfx::Transform& transform, int draw_order_index = 0); @@ -56,11 +56,9 @@ class CC_EXPORT DrawPolygon { const gfx::Vector3dF& normal() const { return normal_; } const DrawQuad* original_ref() const { return original_ref_; } int order_index() const { return order_index_; } - + bool is_split() const { return is_split_; } scoped_ptr<DrawPolygon> CreateCopy(); - static gfx::Vector3dF default_normal; - private: void ApplyTransform(const gfx::Transform& transform); void ApplyTransformToNormal(const gfx::Transform& transform); @@ -76,7 +74,8 @@ class CC_EXPORT DrawPolygon { // we need. // This DrawQuad is owned by the caller and its lifetime must be preserved // as long as this DrawPolygon is alive. - DrawQuad* original_ref_; + const DrawQuad* original_ref_; + bool is_split_; }; } // namespace cc diff --git a/cc/quads/draw_quad.cc b/cc/quads/draw_quad.cc index 8b8fd78..ac1b43e 100644 --- a/cc/quads/draw_quad.cc +++ b/cc/quads/draw_quad.cc @@ -25,9 +25,7 @@ namespace cc { DrawQuad::DrawQuad() - : material(INVALID), - needs_blending(false), - shared_quad_state() { + : material(INVALID), needs_blending(false), shared_quad_state(0) { } void DrawQuad::SetAll(const SharedQuadState* shared_quad_state, diff --git a/cc/resources/layer_quad.cc b/cc/resources/layer_quad.cc index 38ec7b3..ba92314 100644 --- a/cc/resources/layer_quad.cc +++ b/cc/resources/layer_quad.cc @@ -10,8 +10,11 @@ namespace cc { LayerQuad::Edge::Edge(const gfx::PointF& p, const gfx::PointF& q) { - DCHECK(p != q); - + if (p == q) { + degenerate_ = true; + return; + } + degenerate_ = false; gfx::Vector2dF tangent(p.y() - q.y(), q.x() - p.x()); float cross2 = p.x() * q.y() - q.x() * p.y(); @@ -43,6 +46,22 @@ LayerQuad::LayerQuad(const Edge& left, bottom_(bottom) {} gfx::QuadF LayerQuad::ToQuadF() const { + if (left_.degenerate()) { + return gfx::QuadF(top_.Intersect(bottom_), top_.Intersect(right_), + right_.Intersect(bottom_), bottom_.Intersect(top_)); + } + if (right_.degenerate()) { + return gfx::QuadF(left_.Intersect(top_), top_.Intersect(bottom_), + bottom_.Intersect(top_), bottom_.Intersect(left_)); + } + if (top_.degenerate()) { + return gfx::QuadF(left_.Intersect(right_), right_.Intersect(left_), + right_.Intersect(bottom_), bottom_.Intersect(left_)); + } + if (bottom_.degenerate()) { + return gfx::QuadF(left_.Intersect(top_), top_.Intersect(right_), + right_.Intersect(left_), left_.Intersect(right_)); + } return gfx::QuadF(left_.Intersect(top_), top_.Intersect(right_), right_.Intersect(bottom_), @@ -50,18 +69,42 @@ gfx::QuadF LayerQuad::ToQuadF() const { } void LayerQuad::ToFloatArray(float flattened[12]) const { - flattened[0] = left_.x(); - flattened[1] = left_.y(); - flattened[2] = left_.z(); - flattened[3] = top_.x(); - flattened[4] = top_.y(); - flattened[5] = top_.z(); - flattened[6] = right_.x(); - flattened[7] = right_.y(); - flattened[8] = right_.z(); - flattened[9] = bottom_.x(); - flattened[10] = bottom_.y(); - flattened[11] = bottom_.z(); + if (left_.degenerate()) { + flattened[0] = bottom_.x(); + flattened[1] = bottom_.y(); + flattened[2] = bottom_.z(); + } else { + flattened[0] = left_.x(); + flattened[1] = left_.y(); + flattened[2] = left_.z(); + } + if (top_.degenerate()) { + flattened[3] = left_.x(); + flattened[4] = left_.y(); + flattened[5] = left_.z(); + } else { + flattened[3] = top_.x(); + flattened[4] = top_.y(); + flattened[5] = top_.z(); + } + if (right_.degenerate()) { + flattened[6] = top_.x(); + flattened[7] = top_.y(); + flattened[8] = top_.z(); + } else { + flattened[6] = right_.x(); + flattened[7] = right_.y(); + flattened[8] = right_.z(); + } + if (bottom_.degenerate()) { + flattened[9] = right_.x(); + flattened[10] = right_.y(); + flattened[11] = right_.z(); + } else { + flattened[9] = bottom_.x(); + flattened[10] = bottom_.y(); + flattened[11] = bottom_.z(); + } } } // namespace cc diff --git a/cc/resources/layer_quad.h b/cc/resources/layer_quad.h index ed1db10..7433645 100644 --- a/cc/resources/layer_quad.h +++ b/cc/resources/layer_quad.h @@ -22,7 +22,7 @@ class CC_EXPORT LayerQuad { public: class Edge { public: - Edge() : x_(0), y_(0), z_(0) {} + Edge() : x_(0), y_(0), z_(0), degenerate_(false) {} Edge(const gfx::PointF& p, const gfx::PointF& q); float x() const { return x_; } @@ -57,6 +57,8 @@ class CC_EXPORT LayerQuad { } void scale(float s) { scale(s, s, s); } + bool degenerate() const { return degenerate_; } + gfx::PointF Intersect(const Edge& e) const { return gfx::PointF( (y() * e.z() - e.y() * z()) / (x() * e.y() - e.x() * y()), @@ -67,6 +69,7 @@ class CC_EXPORT LayerQuad { float x_; float y_; float z_; + bool degenerate_; }; LayerQuad(const Edge& left, diff --git a/cc/test/data/anti_aliasing.png b/cc/test/data/anti_aliasing.png Binary files differindex 4abe9e1..eba7436 100644 --- a/cc/test/data/anti_aliasing.png +++ b/cc/test/data/anti_aliasing.png diff --git a/cc/test/data/background_filter_blur_off_axis.png b/cc/test/data/background_filter_blur_off_axis.png Binary files differindex 5077171..5e9a0c2 100644 --- a/cc/test/data/background_filter_blur_off_axis.png +++ b/cc/test/data/background_filter_blur_off_axis.png diff --git a/cc/test/data/intersecting_blue_green.png b/cc/test/data/intersecting_blue_green.png Binary files differnew file mode 100644 index 0000000..8262071 --- /dev/null +++ b/cc/test/data/intersecting_blue_green.png diff --git a/cc/test/data/intersecting_blue_green_squares.png b/cc/test/data/intersecting_blue_green_squares.png Binary files differnew file mode 100644 index 0000000..22da4d3 --- /dev/null +++ b/cc/test/data/intersecting_blue_green_squares.png diff --git a/cc/test/data/intersecting_blue_green_squares_video.png b/cc/test/data/intersecting_blue_green_squares_video.png Binary files differnew file mode 100644 index 0000000..e1bea4f --- /dev/null +++ b/cc/test/data/intersecting_blue_green_squares_video.png diff --git a/cc/trees/layer_sorter.cc b/cc/trees/layer_sorter.cc deleted file mode 100644 index bde4920..0000000 --- a/cc/trees/layer_sorter.cc +++ /dev/null @@ -1,470 +0,0 @@ -// Copyright 2011 The Chromium 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 "cc/trees/layer_sorter.h" - -#include <algorithm> -#include <deque> -#include <limits> -#include <vector> - -#include "base/logging.h" -#include "cc/base/math_util.h" -#include "cc/layers/render_surface_impl.h" -#include "ui/gfx/transform.h" - -namespace cc { - -// This epsilon is used to determine if two layers are too close to each other -// to be able to tell which is in front of the other. It's a relative epsilon -// so it is robust to changes in scene scale. This value was chosen by picking -// a value near machine epsilon and then increasing it until the flickering on -// the test scene went away. -const float k_layer_epsilon = 1e-4f; - -inline static float PerpProduct(const gfx::Vector2dF& u, - const gfx::Vector2dF& v) { - return u.x() * v.y() - u.y() * v.x(); -} - -// Tests if two edges defined by their endpoints (a,b) and (c,d) intersect. -// Returns true and the point of intersection if they do and false otherwise. -static bool EdgeEdgeTest(const gfx::PointF& a, - const gfx::PointF& b, - const gfx::PointF& c, - const gfx::PointF& d, - gfx::PointF* r) { - gfx::Vector2dF u = b - a; - gfx::Vector2dF v = d - c; - gfx::Vector2dF w = a - c; - - float denom = PerpProduct(u, v); - - // If denom == 0 then the edges are parallel. While they could be overlapping - // we don't bother to check here as the we'll find their intersections from - // the corner to quad tests. - if (!denom) - return false; - - float s = PerpProduct(v, w) / denom; - if (s < 0.f || s > 1.f) - return false; - - float t = PerpProduct(u, w) / denom; - if (t < 0.f || t > 1.f) - return false; - - u.Scale(s); - *r = a + u; - return true; -} - -GraphNode::GraphNode(LayerImpl* layer_impl) - : layer(layer_impl), - incoming_edge_weight(0.f) {} - -GraphNode::~GraphNode() {} - -LayerSorter::LayerSorter() - : z_range_(0.f) {} - -LayerSorter::~LayerSorter() {} - -static float CheckFloatingPointNumericAccuracy(float a, float b) { - float abs_dif = std::abs(b - a); - float abs_max = std::max(std::abs(b), std::abs(a)); - // Check to see if we've got a result with a reasonable amount of error. - return abs_dif / abs_max; -} - -// Checks whether layer "a" draws on top of layer "b". The weight value returned -// is an indication of the maximum z-depth difference between the layers or zero -// if the layers are found to be intesecting (some features are in front and -// some are behind). -LayerSorter::ABCompareResult LayerSorter::CheckOverlap(LayerShape* a, - LayerShape* b, - float z_threshold, - float* weight) { - *weight = 0.f; - - // Early out if the projected bounds don't overlap. - if (!a->projected_bounds.Intersects(b->projected_bounds)) - return NONE; - - gfx::PointF aPoints[4] = { a->projected_quad.p1(), - a->projected_quad.p2(), - a->projected_quad.p3(), - a->projected_quad.p4() }; - gfx::PointF bPoints[4] = { b->projected_quad.p1(), - b->projected_quad.p2(), - b->projected_quad.p3(), - b->projected_quad.p4() }; - - // Make a list of points that inside both layer quad projections. - std::vector<gfx::PointF> overlap_points; - - // Check all four corners of one layer against the other layer's quad. - for (int i = 0; i < 4; ++i) { - if (a->projected_quad.Contains(bPoints[i])) - overlap_points.push_back(bPoints[i]); - if (b->projected_quad.Contains(aPoints[i])) - overlap_points.push_back(aPoints[i]); - } - - // Check all the edges of one layer for intersection with the other layer's - // edges. - gfx::PointF r; - for (int ea = 0; ea < 4; ++ea) - for (int eb = 0; eb < 4; ++eb) - if (EdgeEdgeTest(aPoints[ea], aPoints[(ea + 1) % 4], - bPoints[eb], bPoints[(eb + 1) % 4], - &r)) - overlap_points.push_back(r); - - if (overlap_points.empty()) - return NONE; - - // Check the corresponding layer depth value for all overlap points to - // determine which layer is in front. - float max_positive = 0.f; - float max_negative = 0.f; - - // This flag tracks the existance of a numerically accurate seperation - // between two layers. If there is no accurate seperation, the layers - // cannot be effectively sorted. - bool accurate = false; - - for (size_t o = 0; o < overlap_points.size(); o++) { - float za = a->LayerZFromProjectedPoint(overlap_points[o]); - float zb = b->LayerZFromProjectedPoint(overlap_points[o]); - - // Here we attempt to avoid numeric issues with layers that are too - // close together. If we have 2-sided quads that are very close - // together then we will draw them in document order to avoid - // flickering. The correct solution is for the content maker to turn - // on back-face culling or move the quads apart (if they're not two - // sides of one object). - if (CheckFloatingPointNumericAccuracy(za, zb) > k_layer_epsilon) - accurate = true; - - float diff = za - zb; - if (diff > max_positive) - max_positive = diff; - if (diff < max_negative) - max_negative = diff; - } - - // If we can't tell which should come first, we use document order. - if (!accurate) - return A_BEFORE_B; - - float max_diff = - std::abs(max_positive) > std::abs(max_negative) ? - max_positive : max_negative; - - // If the results are inconsistent (and the z difference substantial to rule - // out numerical errors) then the layers are intersecting. We will still - // return an order based on the maximum depth difference but with an edge - // weight of zero these layers will get priority if a graph cycle is present - // and needs to be broken. - if (max_positive > z_threshold && max_negative < -z_threshold) - *weight = 0.f; - else - *weight = std::abs(max_diff); - - // Maintain relative order if the layers have the same depth at all - // intersection points. - if (max_diff <= 0.f) - return A_BEFORE_B; - - return B_BEFORE_A; -} - -LayerShape::LayerShape() {} - -LayerShape::LayerShape(float width, - float height, - const gfx::Transform& draw_transform) { - gfx::QuadF layer_quad(gfx::RectF(0.f, 0.f, width, height)); - - // Compute the projection of the layer quad onto the z = 0 plane. - - gfx::PointF clipped_quad[8]; - int num_vertices_in_clipped_quad; - MathUtil::MapClippedQuad(draw_transform, - layer_quad, - clipped_quad, - &num_vertices_in_clipped_quad); - - if (num_vertices_in_clipped_quad < 3) { - projected_bounds = gfx::RectF(); - return; - } - - projected_bounds = - MathUtil::ComputeEnclosingRectOfVertices(clipped_quad, - num_vertices_in_clipped_quad); - - // NOTE: it will require very significant refactoring and overhead to deal - // with generalized polygons or multiple quads per layer here. For the sake of - // layer sorting it is equally correct to take a subsection of the polygon - // that can be made into a quad. This will only be incorrect in the case of - // intersecting layers, which are not supported yet anyway. - projected_quad.set_p1(clipped_quad[0]); - projected_quad.set_p2(clipped_quad[1]); - projected_quad.set_p3(clipped_quad[2]); - if (num_vertices_in_clipped_quad >= 4) { - projected_quad.set_p4(clipped_quad[3]); - } else { - // This will be a degenerate quad that is actually a triangle. - projected_quad.set_p4(clipped_quad[2]); - } - - // Compute the normal of the layer's plane. - bool clipped = false; - gfx::Point3F c1 = - MathUtil::MapPoint(draw_transform, gfx::Point3F(0.f, 0.f, 0.f), &clipped); - gfx::Point3F c2 = - MathUtil::MapPoint(draw_transform, gfx::Point3F(0.f, 1.f, 0.f), &clipped); - gfx::Point3F c3 = - MathUtil::MapPoint(draw_transform, gfx::Point3F(1.f, 0.f, 0.f), &clipped); - // TODO(shawnsingh): Deal with clipping. - gfx::Vector3dF c12 = c2 - c1; - gfx::Vector3dF c13 = c3 - c1; - layer_normal = gfx::CrossProduct(c13, c12); - - transform_origin = c1; -} - -LayerShape::~LayerShape() {} - -// Returns the Z coordinate of a point on the layer that projects -// to point p which lies on the z = 0 plane. It does it by computing the -// intersection of a line starting from p along the Z axis and the plane -// of the layer. -float LayerShape::LayerZFromProjectedPoint(const gfx::PointF& p) const { - gfx::Vector3dF z_axis(0.f, 0.f, 1.f); - gfx::Vector3dF w = gfx::Point3F(p) - transform_origin; - - float d = gfx::DotProduct(layer_normal, z_axis); - float n = -gfx::DotProduct(layer_normal, w); - - // Check if layer is parallel to the z = 0 axis which will make it - // invisible and hence returning zero is fine. - if (!d) - return 0.f; - - // The intersection point would be given by: - // p + (n / d) * u but since we are only interested in the - // z coordinate and p's z coord is zero, all we need is the value of n/d. - return n / d; -} - -void LayerSorter::CreateGraphNodes(LayerImplList::iterator first, - LayerImplList::iterator last) { - DVLOG(2) << "Creating graph nodes:"; - float min_z = FLT_MAX; - float max_z = -FLT_MAX; - for (LayerImplList::const_iterator it = first; it < last; it++) { - nodes_.push_back(GraphNode(*it)); - GraphNode& node = nodes_.at(nodes_.size() - 1); - RenderSurfaceImpl* render_surface = node.layer->render_surface(); - if (!node.layer->DrawsContent() && !render_surface) - continue; - - DVLOG(2) << "Layer " << node.layer->id() << - " (" << node.layer->bounds().width() << - " x " << node.layer->bounds().height() << ")"; - - gfx::Transform draw_transform; - float layer_width, layer_height; - if (render_surface) { - draw_transform = render_surface->draw_transform(); - layer_width = render_surface->content_rect().width(); - layer_height = render_surface->content_rect().height(); - } else { - draw_transform = node.layer->draw_transform(); - layer_width = node.layer->content_bounds().width(); - layer_height = node.layer->content_bounds().height(); - } - - node.shape = LayerShape(layer_width, layer_height, draw_transform); - - max_z = std::max(max_z, node.shape.transform_origin.z()); - min_z = std::min(min_z, node.shape.transform_origin.z()); - } - - z_range_ = std::abs(max_z - min_z); -} - -void LayerSorter::CreateGraphEdges() { - DVLOG(2) << "Edges:"; - // Fraction of the total z_range below which z differences - // are not considered reliable. - const float z_threshold_factor = 0.01f; - float z_threshold = z_range_ * z_threshold_factor; - - for (size_t na = 0; na < nodes_.size(); na++) { - GraphNode& node_a = nodes_[na]; - if (!node_a.layer->DrawsContent() && !node_a.layer->render_surface()) - continue; - for (size_t nb = na + 1; nb < nodes_.size(); nb++) { - GraphNode& node_b = nodes_[nb]; - if (!node_b.layer->DrawsContent() && !node_b.layer->render_surface()) - continue; - float weight = 0.f; - ABCompareResult overlap_result = CheckOverlap(&node_a.shape, - &node_b.shape, - z_threshold, - &weight); - GraphNode* start_node = NULL; - GraphNode* end_node = NULL; - if (overlap_result == A_BEFORE_B) { - start_node = &node_a; - end_node = &node_b; - } else if (overlap_result == B_BEFORE_A) { - start_node = &node_b; - end_node = &node_a; - } - - if (start_node) { - DVLOG(2) << start_node->layer->id() << " -> " << end_node->layer->id(); - edges_.push_back(GraphEdge(start_node, end_node, weight)); - } - } - } - - for (size_t i = 0; i < edges_.size(); i++) { - GraphEdge& edge = edges_[i]; - active_edges_[&edge] = &edge; - edge.from->outgoing.push_back(&edge); - edge.to->incoming.push_back(&edge); - edge.to->incoming_edge_weight += edge.weight; - } -} - -// Finds and removes an edge from the list by doing a swap with the -// last element of the list. -void LayerSorter::RemoveEdgeFromList(GraphEdge* edge, - std::vector<GraphEdge*>* list) { - std::vector<GraphEdge*>::iterator iter = - std::find(list->begin(), list->end(), edge); - DCHECK(iter != list->end()); - list->erase(iter); -} - -// Sorts the given list of layers such that they can be painted in a -// back-to-front order. Sorting produces correct results for non-intersecting -// layers that don't have cyclical order dependencies. Cycles and intersections -// are broken (somewhat) aribtrarily. Sorting of layers is done via a -// topological sort of a directed graph whose nodes are the layers themselves. -// An edge from node A to node B signifies that layer A needs to be drawn before -// layer B. If A and B have no dependency between each other, then we preserve -// the ordering of those layers as they were in the original list. -// -// The draw order between two layers is determined by projecting the two -// triangles making up each layer quad to the Z = 0 plane, finding points of -// intersection between the triangles and backprojecting those points to the -// plane of the layer to determine the corresponding Z coordinate. The layer -// with the lower Z coordinate (farther from the eye) needs to be rendered -// first. -// -// If the layer projections don't intersect, then no edges (dependencies) are -// created between them in the graph. HOWEVER, in this case we still need to -// preserve the ordering of the original list of layers, since that list should -// already have proper z-index ordering of layers. -// -void LayerSorter::Sort(LayerImplList::iterator first, - LayerImplList::iterator last) { - DVLOG(2) << "Sorting start ----"; - CreateGraphNodes(first, last); - - CreateGraphEdges(); - - std::vector<GraphNode*> sorted_list; - std::deque<GraphNode*> no_incoming_edge_node_list; - - // Find all the nodes that don't have incoming edges. - for (NodeList::iterator la = nodes_.begin(); la < nodes_.end(); la++) { - if (!la->incoming.size()) - no_incoming_edge_node_list.push_back(&(*la)); - } - - DVLOG(2) << "Sorted list: "; - while (active_edges_.size() || no_incoming_edge_node_list.size()) { - while (no_incoming_edge_node_list.size()) { - // It is necessary to preserve the existing ordering of layers, when there - // are no explicit dependencies (because this existing ordering has - // correct z-index/layout ordering). To preserve this ordering, we process - // Nodes in the same order that they were added to the list. - GraphNode* from_node = no_incoming_edge_node_list.front(); - no_incoming_edge_node_list.pop_front(); - - // Add it to the final list. - sorted_list.push_back(from_node); - - DVLOG(2) << from_node->layer->id() << ", "; - - // Remove all its outgoing edges from the graph. - for (size_t i = 0; i < from_node->outgoing.size(); i++) { - GraphEdge* outgoing_edge = from_node->outgoing[i]; - - active_edges_.erase(outgoing_edge); - RemoveEdgeFromList(outgoing_edge, &outgoing_edge->to->incoming); - outgoing_edge->to->incoming_edge_weight -= outgoing_edge->weight; - - if (!outgoing_edge->to->incoming.size()) - no_incoming_edge_node_list.push_back(outgoing_edge->to); - } - from_node->outgoing.clear(); - } - - if (!active_edges_.size()) - break; - - // If there are still active edges but the list of nodes without incoming - // edges is empty then we have run into a cycle. Break the cycle by finding - // the node with the smallest overall incoming edge weight and use it. This - // will favor nodes that have zero-weight incoming edges i.e. layers that - // are being occluded by a layer that intersects them. - float min_incoming_edge_weight = FLT_MAX; - GraphNode* next_node = NULL; - for (size_t i = 0; i < nodes_.size(); i++) { - if (nodes_[i].incoming.size() && - nodes_[i].incoming_edge_weight < min_incoming_edge_weight) { - min_incoming_edge_weight = nodes_[i].incoming_edge_weight; - next_node = &nodes_[i]; - } - } - DCHECK(next_node); - // Remove all its incoming edges. - for (size_t e = 0; e < next_node->incoming.size(); e++) { - GraphEdge* incoming_edge = next_node->incoming[e]; - - active_edges_.erase(incoming_edge); - RemoveEdgeFromList(incoming_edge, &incoming_edge->from->outgoing); - } - next_node->incoming.clear(); - next_node->incoming_edge_weight = 0.f; - no_incoming_edge_node_list.push_back(next_node); - DVLOG(2) << "Breaking cycle by cleaning up incoming edges from " << - next_node->layer->id() << - " (weight = " << min_incoming_edge_weight << ")"; - } - - // Note: The original elements of the list are in no danger of having their - // ref count go to zero here as they are all nodes of the layer hierarchy and - // are kept alive by their parent nodes. - int count = 0; - for (LayerImplList::iterator it = first; it < last; it++) - *it = sorted_list[count++]->layer; - - DVLOG(2) << "Sorting end ----"; - - nodes_.clear(); - edges_.clear(); - active_edges_.clear(); -} - -} // namespace cc diff --git a/cc/trees/layer_sorter.h b/cc/trees/layer_sorter.h deleted file mode 100644 index 4cfa8fe..0000000 --- a/cc/trees/layer_sorter.h +++ /dev/null @@ -1,97 +0,0 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#ifndef CC_TREES_LAYER_SORTER_H_ -#define CC_TREES_LAYER_SORTER_H_ - -#include <vector> - -#include "base/basictypes.h" -#include "base/containers/hash_tables.h" -#include "cc/base/cc_export.h" -#include "cc/layers/layer_impl.h" -#include "ui/gfx/geometry/point3_f.h" -#include "ui/gfx/geometry/quad_f.h" -#include "ui/gfx/geometry/rect_f.h" -#include "ui/gfx/geometry/vector3d_f.h" - -namespace gfx { -class Transform; -} - -namespace cc { -struct GraphEdge; - -// Holds various useful properties derived from a layer's 3D outline. -struct CC_EXPORT LayerShape { - LayerShape(); - LayerShape(float width, float height, const gfx::Transform& draw_transform); - ~LayerShape(); - - float LayerZFromProjectedPoint(const gfx::PointF& p) const; - - gfx::Vector3dF layer_normal; - gfx::Point3F transform_origin; - gfx::QuadF projected_quad; - gfx::RectF projected_bounds; -}; - -struct GraphNode { - explicit GraphNode(LayerImpl* layer_impl); - ~GraphNode(); - - LayerImpl* layer; - LayerShape shape; - std::vector<GraphEdge*> incoming; - std::vector<GraphEdge*> outgoing; - float incoming_edge_weight; -}; - -struct GraphEdge { - GraphEdge(GraphNode* from_node, GraphNode* to_node, float weight) - : from(from_node), - to(to_node), - weight(weight) {} - - GraphNode* from; - GraphNode* to; - float weight; -}; - - - -class CC_EXPORT LayerSorter { - public: - LayerSorter(); - ~LayerSorter(); - - void Sort(LayerImplList::iterator first, LayerImplList::iterator last); - - enum ABCompareResult { A_BEFORE_B, B_BEFORE_A, NONE }; - - static ABCompareResult CheckOverlap(LayerShape* a, - LayerShape* b, - float z_threshold, - float* weight); - - private: - typedef std::vector<GraphNode> NodeList; - typedef std::vector<GraphEdge> EdgeList; - NodeList nodes_; - EdgeList edges_; - float z_range_; - - typedef base::hash_map<GraphEdge*, GraphEdge*> EdgeMap; - EdgeMap active_edges_; - - void CreateGraphNodes(LayerImplList::iterator first, - LayerImplList::iterator last); - void CreateGraphEdges(); - void RemoveEdgeFromList(GraphEdge* graph, std::vector<GraphEdge*>* list); - - DISALLOW_COPY_AND_ASSIGN(LayerSorter); -}; - -} // namespace cc -#endif // CC_TREES_LAYER_SORTER_H_ diff --git a/cc/trees/layer_sorter_unittest.cc b/cc/trees/layer_sorter_unittest.cc deleted file mode 100644 index 74d3cf5..0000000 --- a/cc/trees/layer_sorter_unittest.cc +++ /dev/null @@ -1,329 +0,0 @@ -// Copyright 2011 The Chromium 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 "cc/trees/layer_sorter.h" - -#include "cc/base/math_util.h" -#include "cc/layers/layer_impl.h" -#include "cc/test/fake_impl_proxy.h" -#include "cc/test/fake_layer_tree_host_impl.h" -#include "cc/test/test_shared_bitmap_manager.h" -#include "cc/trees/single_thread_proxy.h" -#include "testing/gtest/include/gtest/gtest.h" -#include "ui/gfx/transform.h" - -namespace cc { -namespace { - -// Note: In the following overlap tests, the "camera" is looking down the -// negative Z axis, meaning that layers with smaller z values (more negative) -// are further from the camera and therefore must be drawn before layers with -// higher z values. - -TEST(LayerSorterTest, BasicOverlap) { - LayerSorter::ABCompareResult overlap_result; - const float z_threshold = 0.1f; - float weight = 0.f; - - // Trivial test, with one layer directly obscuring the other. - gfx::Transform neg4_translate; - neg4_translate.Translate3d(0.0, 0.0, -4.0); - LayerShape front(2.f, 2.f, neg4_translate); - - gfx::Transform neg5_translate; - neg5_translate.Translate3d(0.0, 0.0, -5.0); - LayerShape back(2.f, 2.f, neg5_translate); - - overlap_result = - LayerSorter::CheckOverlap(&front, &back, z_threshold, &weight); - EXPECT_EQ(LayerSorter::B_BEFORE_A, overlap_result); - EXPECT_EQ(1.f, weight); - - overlap_result = - LayerSorter::CheckOverlap(&back, &front, z_threshold, &weight); - EXPECT_EQ(LayerSorter::A_BEFORE_B, overlap_result); - EXPECT_EQ(1.f, weight); - - // One layer translated off to the right. No overlap should be detected. - gfx::Transform right_translate; - right_translate.Translate3d(10.0, 0.0, -5.0); - LayerShape back_right(2.f, 2.f, right_translate); - overlap_result = - LayerSorter::CheckOverlap(&front, &back_right, z_threshold, &weight); - EXPECT_EQ(LayerSorter::NONE, overlap_result); - - // When comparing a layer with itself, z difference is always 0. - overlap_result = - LayerSorter::CheckOverlap(&front, &front, z_threshold, &weight); - EXPECT_EQ(0.f, weight); -} - -TEST(LayerSorterTest, RightAngleOverlap) { - LayerSorter::ABCompareResult overlap_result; - const float z_threshold = 0.1f; - float weight = 0.f; - - gfx::Transform perspective_matrix; - perspective_matrix.ApplyPerspectiveDepth(1000.0); - - // Two layers forming a right angle with a perspective viewing transform. - gfx::Transform left_face_matrix; - left_face_matrix.Translate3d(-1.0, 0.0, -5.0); - left_face_matrix.RotateAboutYAxis(-90.0); - left_face_matrix.Translate(-1.0, -1.0); - LayerShape left_face(2.f, 2.f, perspective_matrix * left_face_matrix); - gfx::Transform front_face_matrix; - front_face_matrix.Translate3d(0.0, 0.0, -4.0); - front_face_matrix.Translate(-1.0, -1.0); - LayerShape front_face(2.f, 2.f, perspective_matrix * front_face_matrix); - - overlap_result = - LayerSorter::CheckOverlap(&front_face, &left_face, z_threshold, &weight); - EXPECT_EQ(LayerSorter::B_BEFORE_A, overlap_result); -} - -TEST(LayerSorterTest, IntersectingLayerOverlap) { - LayerSorter::ABCompareResult overlap_result; - const float z_threshold = 0.1f; - float weight = 0.f; - - gfx::Transform perspective_matrix; - perspective_matrix.ApplyPerspectiveDepth(1000.0); - - // Intersecting layers. An explicit order will be returned based on relative z - // values at the overlapping features but the weight returned should be zero. - gfx::Transform front_face_matrix; - front_face_matrix.Translate3d(0.0, 0.0, -4.0); - front_face_matrix.Translate(-1.0, -1.0); - LayerShape front_face(2.f, 2.f, perspective_matrix * front_face_matrix); - - gfx::Transform through_matrix; - through_matrix.Translate3d(0.0, 0.0, -4.0); - through_matrix.RotateAboutYAxis(45.0); - through_matrix.Translate(-1.0, -1.0); - LayerShape rotated_face(2.f, 2.f, perspective_matrix * through_matrix); - overlap_result = LayerSorter::CheckOverlap(&front_face, - &rotated_face, - z_threshold, - &weight); - EXPECT_NE(LayerSorter::NONE, overlap_result); - EXPECT_EQ(0.f, weight); -} - -TEST(LayerSorterTest, LayersAtAngleOverlap) { - LayerSorter::ABCompareResult overlap_result; - const float z_threshold = 0.1f; - float weight = 0.f; - - // Trickier test with layers at an angle. - // - // -x . . . . 0 . . . . +x - // -z / - // : /----B---- - // 0 C - // : ----A----/ - // +z / - // - // C is in front of A and behind B (not what you'd expect by comparing - // centers). A and B don't overlap, so they're incomparable. - - gfx::Transform transform_a; - transform_a.Translate3d(-6.0, 0.0, 1.0); - transform_a.Translate(-4.0, -10.0); - LayerShape layer_a(8.f, 20.f, transform_a); - - gfx::Transform transform_b; - transform_b.Translate3d(6.0, 0.0, -1.0); - transform_b.Translate(-4.0, -10.0); - LayerShape layer_b(8.f, 20.f, transform_b); - - gfx::Transform transform_c; - transform_c.RotateAboutYAxis(40.0); - transform_c.Translate(-4.0, -10.0); - LayerShape layer_c(8.f, 20.f, transform_c); - - overlap_result = - LayerSorter::CheckOverlap(&layer_a, &layer_c, z_threshold, &weight); - EXPECT_EQ(LayerSorter::A_BEFORE_B, overlap_result); - overlap_result = - LayerSorter::CheckOverlap(&layer_c, &layer_b, z_threshold, &weight); - EXPECT_EQ(LayerSorter::A_BEFORE_B, overlap_result); - overlap_result = - LayerSorter::CheckOverlap(&layer_a, &layer_b, z_threshold, &weight); - EXPECT_EQ(LayerSorter::NONE, overlap_result); -} - -TEST(LayerSorterTest, LayersUnderPathologicalPerspectiveTransform) { - LayerSorter::ABCompareResult overlap_result; - const float z_threshold = 0.1f; - float weight = 0.f; - - // On perspective projection, if w becomes negative, the re-projected point - // will be invalid and un-usable. Correct code needs to clip away portions of - // the geometry where w < 0. If the code uses the invalid value, it will think - // that a layer has different bounds than it really does, which can cause - // things to sort incorrectly. - - gfx::Transform perspective_matrix; - perspective_matrix.ApplyPerspectiveDepth(1); - - gfx::Transform transform_a; - transform_a.Translate3d(-15.0, 0.0, -2.0); - transform_a.Translate(-5.0, -5.0); - LayerShape layer_a(10.f, 10.f, perspective_matrix * transform_a); - - // With this sequence of transforms, when layer B is correctly clipped, it - // will be visible on the left half of the projection plane, in front of - // layer_a. When it is not clipped, its bounds will actually incorrectly - // appear much smaller and the correct sorting dependency will not be found. - gfx::Transform transform_b; - transform_b.Translate3d(0.f, 0.f, 0.7f); - transform_b.RotateAboutYAxis(45.0); - transform_b.Translate(-5.0, -5.0); - LayerShape layer_b(10.f, 10.f, perspective_matrix * transform_b); - - // Sanity check that the test case actually covers the intended scenario, - // where part of layer B go behind the w = 0 plane. - gfx::QuadF test_quad = gfx::QuadF(gfx::RectF(-0.5f, -0.5f, 1.f, 1.f)); - bool clipped = false; - MathUtil::MapQuad(perspective_matrix * transform_b, test_quad, &clipped); - ASSERT_TRUE(clipped); - - overlap_result = - LayerSorter::CheckOverlap(&layer_a, &layer_b, z_threshold, &weight); - EXPECT_EQ(LayerSorter::A_BEFORE_B, overlap_result); -} - -TEST(LayerSorterTest, VerifyExistingOrderingPreservedWhenNoZDiff) { - // If there is no reason to re-sort the layers (i.e. no 3d z difference), then - // the existing ordering provided on input should be retained. This test - // covers the fix in https://bugs.webkit.org/show_bug.cgi?id=75046. Before - // this fix, ordering was accidentally reversed, causing bugs in z-index - // ordering on websites when preserves3D triggered the LayerSorter. - - // Input list of layers: [1, 2, 3, 4, 5]. - // Expected output: [3, 4, 1, 2, 5]. - // - 1, 2, and 5 do not have a 3d z difference, and therefore their - // relative ordering should be retained. - // - 3 and 4 do not have a 3d z difference, and therefore their relative - // ordering should be retained. - // - 3 and 4 should be re-sorted so they are in front of 1, 2, and 5. - - FakeImplProxy proxy; - TestSharedBitmapManager shared_bitmap_manager; - FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); - - scoped_ptr<LayerImpl> layer1 = LayerImpl::Create(host_impl.active_tree(), 1); - scoped_ptr<LayerImpl> layer2 = LayerImpl::Create(host_impl.active_tree(), 2); - scoped_ptr<LayerImpl> layer3 = LayerImpl::Create(host_impl.active_tree(), 3); - scoped_ptr<LayerImpl> layer4 = LayerImpl::Create(host_impl.active_tree(), 4); - scoped_ptr<LayerImpl> layer5 = LayerImpl::Create(host_impl.active_tree(), 5); - - gfx::Transform BehindMatrix; - BehindMatrix.Translate3d(0.0, 0.0, 2.0); - gfx::Transform FrontMatrix; - FrontMatrix.Translate3d(0.0, 0.0, 1.0); - - layer1->SetBounds(gfx::Size(10, 10)); - layer1->SetContentBounds(gfx::Size(10, 10)); - layer1->draw_properties().target_space_transform = BehindMatrix; - layer1->SetDrawsContent(true); - - layer2->SetBounds(gfx::Size(20, 20)); - layer2->SetContentBounds(gfx::Size(20, 20)); - layer2->draw_properties().target_space_transform = BehindMatrix; - layer2->SetDrawsContent(true); - - layer3->SetBounds(gfx::Size(30, 30)); - layer3->SetContentBounds(gfx::Size(30, 30)); - layer3->draw_properties().target_space_transform = FrontMatrix; - layer3->SetDrawsContent(true); - - layer4->SetBounds(gfx::Size(40, 40)); - layer4->SetContentBounds(gfx::Size(40, 40)); - layer4->draw_properties().target_space_transform = FrontMatrix; - layer4->SetDrawsContent(true); - - layer5->SetBounds(gfx::Size(50, 50)); - layer5->SetContentBounds(gfx::Size(50, 50)); - layer5->draw_properties().target_space_transform = BehindMatrix; - layer5->SetDrawsContent(true); - - LayerImplList layer_list; - layer_list.push_back(layer1.get()); - layer_list.push_back(layer2.get()); - layer_list.push_back(layer3.get()); - layer_list.push_back(layer4.get()); - layer_list.push_back(layer5.get()); - - ASSERT_EQ(5u, layer_list.size()); - EXPECT_EQ(1, layer_list[0]->id()); - EXPECT_EQ(2, layer_list[1]->id()); - EXPECT_EQ(3, layer_list[2]->id()); - EXPECT_EQ(4, layer_list[3]->id()); - EXPECT_EQ(5, layer_list[4]->id()); - - LayerSorter layer_sorter; - layer_sorter.Sort(layer_list.begin(), layer_list.end()); - - ASSERT_EQ(5u, layer_list.size()); - EXPECT_EQ(3, layer_list[0]->id()); - EXPECT_EQ(4, layer_list[1]->id()); - EXPECT_EQ(1, layer_list[2]->id()); - EXPECT_EQ(2, layer_list[3]->id()); - EXPECT_EQ(5, layer_list[4]->id()); -} - -TEST(LayerSorterTest, VerifyConcidentLayerPrecisionLossResultsInDocumentOrder) { - FakeImplProxy proxy; - TestSharedBitmapManager shared_bitmap_manager; - FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); - - scoped_ptr<LayerImpl> layer1 = LayerImpl::Create(host_impl.active_tree(), 1); - scoped_ptr<LayerImpl> layer2 = LayerImpl::Create(host_impl.active_tree(), 2); - - // Layer 1 should occur before layer 2 in paint. However, due to numeric - // issues in the sorter, it will put the layers in the wrong order - // in some situations. Here we test a patch that results in document - // order rather than calculated order when numeric percision is suspect - // in calculated order. - - gfx::Transform BehindMatrix; - BehindMatrix.Translate3d(0.f, 0.f, 0.999999f); - BehindMatrix.RotateAboutXAxis(38.5); - BehindMatrix.RotateAboutYAxis(77.0); - gfx::Transform FrontMatrix; - FrontMatrix.Translate3d(0, 0, 1.0); - FrontMatrix.RotateAboutXAxis(38.5); - FrontMatrix.RotateAboutYAxis(77.0); - - layer1->SetBounds(gfx::Size(10, 10)); - layer1->SetContentBounds(gfx::Size(10, 10)); - layer1->draw_properties().target_space_transform = BehindMatrix; - layer1->SetDrawsContent(true); - - layer2->SetBounds(gfx::Size(10, 10)); - layer2->SetContentBounds(gfx::Size(10, 10)); - layer2->draw_properties().target_space_transform = FrontMatrix; - layer2->SetDrawsContent(true); - - LayerImplList layer_list; - layer_list.push_back(layer1.get()); - layer_list.push_back(layer2.get()); - - ASSERT_EQ(2u, layer_list.size()); - EXPECT_EQ(1, layer_list[0]->id()); - EXPECT_EQ(2, layer_list[1]->id()); - - LayerSorter layer_sorter; - layer_sorter.Sort(layer_list.begin(), layer_list.end()); - - ASSERT_EQ(2u, layer_list.size()); - EXPECT_EQ(1, layer_list[0]->id()); - EXPECT_EQ(2, layer_list[1]->id()); -} - -} // namespace -} // namespace cc - diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc index 9059ae1..064e91e 100644 --- a/cc/trees/layer_tree_host_common.cc +++ b/cc/trees/layer_tree_host_common.cc @@ -15,7 +15,6 @@ #include "cc/layers/render_surface.h" #include "cc/layers/render_surface_impl.h" #include "cc/trees/draw_property_utils.h" -#include "cc/trees/layer_sorter.h" #include "cc/trees/layer_tree_host.h" #include "cc/trees/layer_tree_impl.h" #include "ui/gfx/geometry/rect_conversions.h" @@ -31,20 +30,6 @@ ScrollAndScaleSet::ScrollAndScaleSet() ScrollAndScaleSet::~ScrollAndScaleSet() {} -static void SortLayers(LayerList::iterator first, - LayerList::iterator end, - void* layer_sorter) { - NOTREACHED(); -} - -static void SortLayers(LayerImplList::iterator first, - LayerImplList::iterator end, - LayerSorter* layer_sorter) { - DCHECK(layer_sorter); - TRACE_EVENT0("cc", "LayerTreeHostCommon::SortLayers"); - layer_sorter->Sort(first, end); -} - template <typename LayerType> static gfx::Vector2dF GetEffectiveScrollDelta(LayerType* layer) { // Layer's scroll offset can have an integer part and fractional part. @@ -1281,7 +1266,6 @@ static void PreCalculateMetaInformation( template <typename LayerType> struct SubtreeGlobals { - LayerSorter* layer_sorter; int max_texture_size; float device_scale_factor; float page_scale_factor; @@ -2371,17 +2355,6 @@ static void CalculateDrawPropertiesInternal( return; } - // If preserves-3d then sort all the descendants in 3D so that they can be - // drawn from back to front. If the preserves-3d property is also set on the - // parent then skip the sorting as the parent will sort all the descendants - // anyway. - if (globals.layer_sorter && descendants.size() && layer->Is3dSorted() && - !LayerIsInExisting3DRenderingContext(layer)) { - SortLayers(descendants.begin() + sorting_start_index, - descendants.end(), - globals.layer_sorter); - } - UpdateAccumulatedSurfaceState<LayerType>( layer, local_drawable_content_rect_of_subtree, accumulated_surface_state); @@ -2419,7 +2392,6 @@ static void ProcessCalcDrawPropsInputs( scaled_device_transform.Scale(inputs.device_scale_factor, inputs.device_scale_factor); - globals->layer_sorter = NULL; globals->max_texture_size = inputs.max_texture_size; globals->device_scale_factor = inputs.device_scale_factor * device_transform_scale; @@ -2583,9 +2555,6 @@ void LayerTreeHostCommon::CalculateDrawProperties( DataForRecursion<LayerImpl> data_for_recursion; ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion); - LayerSorter layer_sorter; - globals.layer_sorter = &layer_sorter; - PreCalculateMetaInformationRecursiveData recursive_data; PreCalculateMetaInformation(inputs->root_layer, &recursive_data); std::vector<AccumulatedSurfaceState<LayerImpl>> accumulated_surface_state; diff --git a/cc/trees/layer_tree_host_common_perftest.cc b/cc/trees/layer_tree_host_common_perftest.cc index 73d5c1d..1732e5588 100644 --- a/cc/trees/layer_tree_host_common_perftest.cc +++ b/cc/trees/layer_tree_host_common_perftest.cc @@ -25,7 +25,6 @@ #include "cc/test/layer_tree_json_parser.h" #include "cc/test/layer_tree_test.h" #include "cc/test/paths.h" -#include "cc/trees/layer_sorter.h" #include "cc/trees/layer_tree_impl.h" #include "testing/perf/perf_test.h" @@ -162,55 +161,7 @@ class CalcDrawPropsImplTest : public LayerTreeHostCommonPerfTest { } }; -class LayerSorterMainTest : public CalcDrawPropsImplTest { - public: - void RunSortLayers() { RunTest(false, false, false); } - - void BeginTest() override { PostSetNeedsCommitToMainThread(); } - - void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override { - LayerTreeImpl* active_tree = host_impl->active_tree(); - // First build the tree and then we'll start running tests on layersorter - // itself - bool can_render_to_separate_surface = true; - int max_texture_size = 8096; - DoCalcDrawPropertiesImpl(can_render_to_separate_surface, - max_texture_size, - active_tree, - host_impl); - - // Behaviour of this test is different from that of sorting in practice. - // In this case, all layers that exist in any 3D context are put into a list - // and are sorted as one big 3D context instead of several smaller ones. - BuildLayerImplList(active_tree->root_layer(), &base_list_); - timer_.Reset(); - do { - // Here we'll move the layers into a LayerImpl list of their own to be - // sorted so we don't have a sorted list for every run after the first - LayerImplList test_list = base_list_; - layer_sorter_.Sort(test_list.begin(), test_list.end()); - timer_.NextLap(); - } while (!timer_.HasTimeLimitExpired()); - - EndTest(); - } - - void BuildLayerImplList(LayerImpl* layer, LayerImplList* list) { - if (layer->Is3dSorted()) { - list->push_back(layer); - } - - for (size_t i = 0; i < layer->children().size(); i++) { - BuildLayerImplList(layer->children()[i], list); - } - } - - private: - LayerImplList base_list_; - LayerSorter layer_sorter_; -}; - -class BspTreePerfTest : public LayerSorterMainTest { +class BspTreePerfTest : public CalcDrawPropsImplTest { public: void RunSortLayers() { RunTest(false, false, false); } @@ -261,7 +212,18 @@ class BspTreePerfTest : public LayerSorterMainTest { EndTest(); } + void BuildLayerImplList(LayerImpl* layer, LayerImplList* list) { + if (layer->Is3dSorted()) { + list->push_back(layer); + } + + for (size_t i = 0; i < layer->children().size(); i++) { + BuildLayerImplList(layer->children()[i], list); + } + } + private: + LayerImplList base_list_; int num_duplicates_; }; @@ -313,13 +275,13 @@ TEST_F(CalcDrawPropsImplTest, TouchRegionHeavy) { RunCalcDrawProps(); } -TEST_F(LayerSorterMainTest, LayerSorterCubes) { +TEST_F(BspTreePerfTest, LayerSorterCubes) { SetTestName("layer_sort_cubes"); ReadTestFile("layer_sort_cubes"); RunSortLayers(); } -TEST_F(LayerSorterMainTest, LayerSorterRubik) { +TEST_F(BspTreePerfTest, LayerSorterRubik) { SetTestName("layer_sort_rubik"); ReadTestFile("layer_sort_rubik"); // TODO(vollick): Remove verify_property_trees setting after diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc index 6c0d1ae..d2c473e 100644 --- a/cc/trees/layer_tree_host_common_unittest.cc +++ b/cc/trees/layer_tree_host_common_unittest.cc @@ -3043,78 +3043,6 @@ TEST_F(LayerTreeHostCommonTest, EXPECT_FALSE(child->draw_properties().sorted_for_recursion); } -TEST_F(LayerTreeHostCommonTest, WillSortAtContextBoundary) { - // Creates a layer tree that looks as follows: - // * root (sorting-context-id1) - // * parent (sorting-context-id2) - // * child1 (sorting-context-id2) - // * child2 (sorting-context-id2) - // - // This test ensures that we sort at |parent| even though both it and root are - // set to be 3d sorted. - FakeImplProxy proxy; - TestSharedBitmapManager shared_bitmap_manager; - FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); - - scoped_ptr<LayerImpl> root_ptr(LayerImpl::Create(host_impl.active_tree(), 1)); - LayerImpl* root = root_ptr.get(); - scoped_ptr<LayerImpl> parent_ptr( - LayerImpl::Create(host_impl.active_tree(), 2)); - LayerImpl* parent = parent_ptr.get(); - scoped_ptr<LayerImpl> child1_ptr( - LayerImpl::Create(host_impl.active_tree(), 3)); - LayerImpl* child1 = child1_ptr.get(); - scoped_ptr<LayerImpl> child2_ptr( - LayerImpl::Create(host_impl.active_tree(), 4)); - LayerImpl* child2 = child2_ptr.get(); - - gfx::Transform identity_matrix; - gfx::Transform below_matrix; - below_matrix.Translate3d(0.f, 0.f, -10.f); - gfx::Transform above_matrix; - above_matrix.Translate3d(0.f, 0.f, 10.f); - - SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(), - gfx::PointF(), gfx::Size(100, 100), true, true, - true); - SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(), - gfx::PointF(), gfx::Size(50, 50), true, true, - true); - SetLayerPropertiesForTesting(child1, above_matrix, gfx::Point3F(), - gfx::PointF(), gfx::Size(50, 50), true, true, - false); - SetLayerPropertiesForTesting(child2, below_matrix, gfx::Point3F(), - gfx::PointF(), gfx::Size(50, 50), true, true, - false); - - root->Set3dSortingContextId(3); - root->SetDrawsContent(true); - parent->Set3dSortingContextId(7); - parent->SetDrawsContent(true); - child1->Set3dSortingContextId(7); - child1->SetDrawsContent(true); - child2->Set3dSortingContextId(7); - child2->SetDrawsContent(true); - - parent->AddChild(child1_ptr.Pass()); - parent->AddChild(child2_ptr.Pass()); - root->AddChild(parent_ptr.Pass()); - - LayerImplList render_surface_layer_list; - LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( - root_ptr.get(), root->bounds(), &render_surface_layer_list); - inputs.can_adjust_raster_scales = true; - LayerTreeHostCommon::CalculateDrawProperties(&inputs); - - EXPECT_TRUE(root->render_surface()); - EXPECT_EQ(2u, render_surface_layer_list.size()); - - EXPECT_EQ(3u, parent->render_surface()->layer_list().size()); - EXPECT_EQ(child2->id(), parent->render_surface()->layer_list().at(0)->id()); - EXPECT_EQ(parent->id(), parent->render_surface()->layer_list().at(1)->id()); - EXPECT_EQ(child1->id(), parent->render_surface()->layer_list().at(2)->id()); -} - TEST_F(LayerTreeHostCommonTest, SingularNonAnimatingTransformDoesNotPreventClearingDrawProperties) { scoped_refptr<Layer> root = Layer::Create(); @@ -7660,110 +7588,6 @@ TEST_F(LayerTreeHostCommonTest, OutOfOrderClippingRequiresRSLLSorting) { EXPECT_TRUE(render_surface_layer_list.at(2)->render_surface()); } -TEST_F(LayerTreeHostCommonTest, DoNotClobberSorting) { - // We rearrange layer list contributions if we have to visit children out of - // order, but it should be a 'stable' rearrangement. That is, the layer list - // additions for a single layer should not be reordered, though their position - // wrt to the contributions due to a sibling may vary. - // - // + root - // + scroll_child - // + top_content - // + bottom_content - // + scroll_parent_border - // + scroll_parent_clip - // + scroll_parent - // - FakeImplProxy proxy; - TestSharedBitmapManager shared_bitmap_manager; - FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); - host_impl.CreatePendingTree(); - scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1); - scoped_ptr<LayerImpl> scroll_parent_border = - LayerImpl::Create(host_impl.active_tree(), 2); - scoped_ptr<LayerImpl> scroll_parent_clip = - LayerImpl::Create(host_impl.active_tree(), 3); - scoped_ptr<LayerImpl> scroll_parent = - LayerImpl::Create(host_impl.active_tree(), 4); - scoped_ptr<LayerImpl> scroll_child = - LayerImpl::Create(host_impl.active_tree(), 5); - scoped_ptr<LayerImpl> bottom_content = - LayerImpl::Create(host_impl.active_tree(), 6); - scoped_ptr<LayerImpl> top_content = - LayerImpl::Create(host_impl.active_tree(), 7); - - scroll_parent_clip->SetMasksToBounds(true); - - scroll_child->SetScrollParent(scroll_parent.get()); - scoped_ptr<std::set<LayerImpl*>> scroll_children(new std::set<LayerImpl*>); - scroll_children->insert(scroll_child.get()); - scroll_parent->SetScrollChildren(scroll_children.release()); - - scroll_child->SetDrawsContent(true); - scroll_parent->SetDrawsContent(true); - top_content->SetDrawsContent(true); - bottom_content->SetDrawsContent(true); - - gfx::Transform identity_transform; - gfx::Transform top_transform; - top_transform.Translate3d(0.0, 0.0, 5.0); - gfx::Transform bottom_transform; - bottom_transform.Translate3d(0.0, 0.0, 3.0); - - SetLayerPropertiesForTesting(root.get(), identity_transform, gfx::Point3F(), - gfx::PointF(), gfx::Size(50, 50), true, false, - true); - SetLayerPropertiesForTesting(scroll_parent_border.get(), identity_transform, - gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40), - true, false, false); - SetLayerPropertiesForTesting(scroll_parent_clip.get(), identity_transform, - gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30), - true, false, false); - SetLayerPropertiesForTesting(scroll_parent.get(), identity_transform, - gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50), - true, false, false); - SetLayerPropertiesForTesting(scroll_child.get(), identity_transform, - gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50), - true, false, false); - SetLayerPropertiesForTesting(top_content.get(), top_transform, gfx::Point3F(), - gfx::PointF(), gfx::Size(50, 50), false, true, - true); - SetLayerPropertiesForTesting(bottom_content.get(), bottom_transform, - gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50), - false, true, true); - - scroll_child->SetShouldFlattenTransform(false); - scroll_child->Set3dSortingContextId(1); - - scroll_child->AddChild(top_content.Pass()); - scroll_child->AddChild(bottom_content.Pass()); - root->AddChild(scroll_child.Pass()); - - scroll_parent_clip->AddChild(scroll_parent.Pass()); - scroll_parent_border->AddChild(scroll_parent_clip.Pass()); - root->AddChild(scroll_parent_border.Pass()); - - LayerImplList render_surface_layer_list; - LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( - root.get(), root->bounds(), &render_surface_layer_list); - - LayerTreeHostCommon::CalculateDrawProperties(&inputs); - - EXPECT_TRUE(root->render_surface()); - - // If we don't sort by depth and let the layers get added in the order they - // would normally be visited in, then layers 6 and 7 will be out of order. In - // other words, although we've had to shift 5, 6, and 7 to appear before 4 - // in the list (because of the scroll parent relationship), this should not - // have an effect on the the order of 5, 6, and 7 (which had been reordered - // due to layer sorting). - EXPECT_EQ(4u, root->render_surface()->layer_list().size()); - EXPECT_EQ(5, root->render_surface()->layer_list().at(0)->id()); - EXPECT_EQ(6, root->render_surface()->layer_list().at(1)->id()); - EXPECT_EQ(7, root->render_surface()->layer_list().at(2)->id()); - EXPECT_EQ(4, root->render_surface()->layer_list().at(3)->id()); -} - TEST_F(LayerTreeHostCommonTest, ScrollCompensationWithRounding) { // This test verifies that a scrolling layer that gets snapped to // integer coordinates doesn't move a fixed position child. diff --git a/cc/trees/layer_tree_host_pixeltest_filters.cc b/cc/trees/layer_tree_host_pixeltest_filters.cc index 76acaa8..dd3cf73 100644 --- a/cc/trees/layer_tree_host_pixeltest_filters.cc +++ b/cc/trees/layer_tree_host_pixeltest_filters.cc @@ -97,8 +97,8 @@ TEST_F(LayerTreeHostFiltersPixelTest, BackgroundFilterBlurOutsets) { } TEST_F(LayerTreeHostFiltersPixelTest, BackgroundFilterBlurOffAxis) { - scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer( - gfx::Rect(200, 200), SK_ColorWHITE); + scoped_refptr<SolidColorLayer> background = + CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorTRANSPARENT); // This verifies that the perspective of the clear layer (with black border) // does not influence the blending of the green box behind it. Also verifies diff --git a/cc/trees/layer_tree_impl_unittest.cc b/cc/trees/layer_tree_impl_unittest.cc index 67f98e65..06df3c2 100644 --- a/cc/trees/layer_tree_impl_unittest.cc +++ b/cc/trees/layer_tree_impl_unittest.cc @@ -920,14 +920,6 @@ TEST_F(LayerTreeImplTest, HitTestingForMultipleLayersAtVaryingDepths) { ASSERT_TRUE(grand_child1); ASSERT_EQ(1u, RenderSurfaceLayerList().size()); - RenderSurfaceImpl* root_render_surface = - host_impl().active_tree()->root_layer()->render_surface(); - ASSERT_EQ(4u, root_render_surface->layer_list().size()); - ASSERT_EQ(3, root_render_surface->layer_list().at(0)->id()); - ASSERT_EQ(1, root_render_surface->layer_list().at(1)->id()); - ASSERT_EQ(2, root_render_surface->layer_list().at(2)->id()); - ASSERT_EQ(4, root_render_surface->layer_list().at(3)->id()); - // Nothing overlaps the root_layer at (1, 1), so hit testing there should find // the root layer. gfx::Point test_point = gfx::Point(1, 1); diff --git a/cc/trees/occlusion_tracker.cc b/cc/trees/occlusion_tracker.cc index 388eb6e..0f0ce15 100644 --- a/cc/trees/occlusion_tracker.cc +++ b/cc/trees/occlusion_tracker.cc @@ -155,7 +155,7 @@ static inline bool LayerIsInUnsorted3dRenderingContext(const Layer* layer) { return layer->Is3dSorted(); } static inline bool LayerIsInUnsorted3dRenderingContext(const LayerImpl* layer) { - return false; + return layer->Is3dSorted(); } template <typename LayerType> diff --git a/cc/trees/occlusion_tracker_unittest.cc b/cc/trees/occlusion_tracker_unittest.cc index e3639ad..f3f2185 100644 --- a/cc/trees/occlusion_tracker_unittest.cc +++ b/cc/trees/occlusion_tracker_unittest.cc @@ -1540,56 +1540,6 @@ class OcclusionTrackerTestLayerBehindCameraDoesNotOcclude } }; -// This test requires accumulating occlusion of 3d layers, which are skipped by -// the occlusion tracker on the main thread. So this test should run on the impl -// thread. -IMPL_THREAD_TEST(OcclusionTrackerTestLayerBehindCameraDoesNotOcclude); - -template <class Types> -class OcclusionTrackerTestLargePixelsOccludeInsideClipRect - : public OcclusionTrackerTest<Types> { - protected: - explicit OcclusionTrackerTestLargePixelsOccludeInsideClipRect( - bool opaque_layers) - : OcclusionTrackerTest<Types>(opaque_layers) {} - void RunMyTest() override { - gfx::Transform transform; - transform.Translate(50.0, 50.0); - transform.ApplyPerspectiveDepth(100.0); - transform.Translate3d(0.0, 0.0, 99.0); - transform.Translate(-50.0, -50.0); - - typename Types::ContentLayerType* parent = this->CreateRoot( - this->identity_matrix, gfx::PointF(), gfx::Size(100, 100)); - parent->SetMasksToBounds(true); - typename Types::ContentLayerType* layer = this->CreateDrawingLayer( - parent, transform, gfx::PointF(), gfx::Size(100, 100), true); - parent->SetShouldFlattenTransform(false); - parent->Set3dSortingContextId(1); - layer->SetShouldFlattenTransform(false); - layer->Set3dSortingContextId(1); - this->CalcDrawEtc(parent); - - TestOcclusionTrackerWithClip<typename Types::LayerType> occlusion( - gfx::Rect(0, 0, 1000, 1000)); - - // This is very close to the camera, so pixels in its visible_content_rect() - // will actually go outside of the layer's clip rect. Ensure that those - // pixels don't occlude things outside the clip rect. - this->VisitLayer(layer, &occlusion); - this->EnterLayer(parent, &occlusion); - EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), - occlusion.occlusion_from_inside_target().ToString()); - EXPECT_EQ(gfx::Rect().ToString(), - occlusion.occlusion_from_outside_target().ToString()); - } -}; - -// This test requires accumulating occlusion of 3d layers, which are skipped by -// the occlusion tracker on the main thread. So this test should run on the impl -// thread. -IMPL_THREAD_TEST(OcclusionTrackerTestLargePixelsOccludeInsideClipRect); - template <class Types> class OcclusionTrackerTestAnimationOpacity1OnMainThread : public OcclusionTrackerTest<Types> { |
