#include "cc/debug/debug_colors.h"
#include "cc/layers/delegated_renderer_layer_impl.h"
#include "cc/layers/layer_impl.h"
-#include "cc/layers/quad_sink.h"
#include "cc/layers/render_pass_sink.h"
#include "cc/quads/debug_border_draw_quad.h"
#include "cc/quads/render_pass.h"
#include "cc/quads/render_pass_draw_quad.h"
#include "cc/quads/shared_quad_state.h"
#include "cc/trees/damage_tracker.h"
+#include "cc/trees/occlusion_tracker.h"
#include "third_party/skia/include/core/SkImageFilter.h"
-#include "ui/gfx/rect_conversions.h"
+#include "ui/gfx/geometry/rect_conversions.h"
#include "ui/gfx/transform.h"
namespace cc {
is_clipped_(false),
contributes_to_drawn_surface_(false),
draw_opacity_(1),
- nearest_occlusion_immune_ancestor_(NULL),
+ nearest_occlusion_immune_ancestor_(nullptr),
target_render_surface_layer_index_history_(0),
current_layer_index_history_(0) {
damage_tracker_ = DamageTracker::Create();
clip_rect_ = clip_rect;
}
-bool RenderSurfaceImpl::ContentsChanged() const {
- return !damage_tracker_->current_damage_rect().IsEmpty();
-}
-
void RenderSurfaceImpl::SetContentRect(const gfx::Rect& content_rect) {
if (content_rect_ == content_rect)
return;
contributing_delegated_render_pass_layer_list_.clear();
}
-RenderPass::Id RenderSurfaceImpl::RenderPassId() {
+RenderPassId RenderSurfaceImpl::GetRenderPassId() {
int layer_id = owning_layer_->id();
int sub_id = 0;
DCHECK_GT(layer_id, 0);
- return RenderPass::Id(layer_id, sub_id);
+ return RenderPassId(layer_id, sub_id);
}
void RenderSurfaceImpl::AppendRenderPasses(RenderPassSink* pass_sink) {
}
scoped_ptr<RenderPass> pass = RenderPass::Create(layer_list_.size());
- pass->SetNew(RenderPassId(),
+ pass->SetNew(GetRenderPassId(),
content_rect_,
gfx::IntersectRects(content_rect_,
damage_tracker_->current_damage_rect()),
pass_sink->AppendRenderPass(pass.Pass());
}
-void RenderSurfaceImpl::AppendQuads(QuadSink* quad_sink,
- AppendQuadsData* append_quads_data,
- bool for_replica,
- RenderPass::Id render_pass_id) {
+void RenderSurfaceImpl::AppendQuads(
+ RenderPass* render_pass,
+ const OcclusionTracker<LayerImpl>& occlusion_tracker,
+ AppendQuadsData* append_quads_data,
+ bool for_replica,
+ RenderPassId render_pass_id) {
DCHECK(!for_replica || owning_layer_->has_replica());
const gfx::Transform& draw_transform =
for_replica ? replica_draw_transform_ : draw_transform_;
gfx::Rect visible_content_rect =
- quad_sink->UnoccludedContributingSurfaceContentRect(content_rect_,
- draw_transform);
+ occlusion_tracker.UnoccludedContributingSurfaceContentRect(
+ content_rect_, draw_transform);
if (visible_content_rect.IsEmpty())
return;
- SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+ SharedQuadState* shared_quad_state =
+ render_pass->CreateAndAppendSharedQuadState();
shared_quad_state->SetAll(draw_transform,
content_rect_.size(),
content_rect_,
owning_layer_->layer_tree_impl()) :
DebugColors::SurfaceBorderWidth(
owning_layer_->layer_tree_impl());
- scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
- DebugBorderDrawQuad::Create();
+ DebugBorderDrawQuad* debug_border_quad =
+ render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
debug_border_quad->SetNew(
shared_quad_state, content_rect_, visible_content_rect, color, width);
- quad_sink->Append(debug_border_quad.PassAs<DrawQuad>());
}
// TODO(shawnsingh): By using the same RenderSurfaceImpl for both the content
LayerImpl* mask_layer = owning_layer_->mask_layer();
if (mask_layer &&
(!mask_layer->DrawsContent() || mask_layer->bounds().IsEmpty()))
- mask_layer = NULL;
+ mask_layer = nullptr;
if (!mask_layer && for_replica) {
mask_layer = owning_layer_->replica_layer()->mask_layer();
if (mask_layer &&
(!mask_layer->DrawsContent() || mask_layer->bounds().IsEmpty()))
- mask_layer = NULL;
+ mask_layer = nullptr;
}
- gfx::RectF mask_uv_rect(0.f, 0.f, 1.f, 1.f);
+ ResourceProvider::ResourceId mask_resource_id = 0;
+ gfx::Size mask_texture_size;
+ gfx::Vector2dF mask_uv_scale;
if (mask_layer) {
+ mask_layer->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
gfx::Vector2dF owning_layer_draw_scale =
MathUtil::ComputeTransform2dScaleComponents(
owning_layer_->draw_transform(), 1.f);
owning_layer_->content_bounds(),
owning_layer_draw_scale.x(),
owning_layer_draw_scale.y());
-
- float uv_scale_x =
- content_rect_.width() / unclipped_mask_target_size.width();
- float uv_scale_y =
- content_rect_.height() / unclipped_mask_target_size.height();
-
- mask_uv_rect = gfx::RectF(
- uv_scale_x * content_rect_.x() / content_rect_.width(),
- uv_scale_y * content_rect_.y() / content_rect_.height(),
- uv_scale_x,
- uv_scale_y);
+ mask_uv_scale = gfx::Vector2dF(
+ content_rect_.width() / unclipped_mask_target_size.width(),
+ content_rect_.height() / unclipped_mask_target_size.height());
}
- ResourceProvider::ResourceId mask_resource_id =
- mask_layer ? mask_layer->ContentsResourceId() : 0;
- gfx::Rect contents_changed_since_last_frame =
- ContentsChanged() ? content_rect_ : gfx::Rect();
+ DCHECK(owning_layer_->draw_properties().target_space_transform.IsScale2d());
+ gfx::Vector2dF owning_layer_to_target_scale =
+ owning_layer_->draw_properties().target_space_transform.Scale2d();
+ owning_layer_to_target_scale.Scale(owning_layer_->contents_scale_x(),
+ owning_layer_->contents_scale_y());
- scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
+ RenderPassDrawQuad* quad =
+ render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
quad->SetNew(shared_quad_state,
content_rect_,
visible_content_rect,
render_pass_id,
- for_replica,
mask_resource_id,
- contents_changed_since_last_frame,
- mask_uv_rect,
+ mask_uv_scale,
+ mask_texture_size,
owning_layer_->filters(),
+ owning_layer_to_target_scale,
owning_layer_->background_filters());
- quad_sink->Append(quad.PassAs<DrawQuad>());
}
} // namespace cc
projects / platform / framework / web / crosswalk.git / blobdiff